<?xml version="1.0"?>
<doc>
    <assembly>
        <name>HSS.Core</name>
    </assembly>
    <members>
        <member name="T:HSS.IO.Zip.ZipFile">
            <summary>
            <para>The ZipFile type represents a zip archive file.
            This class reads and writes zip files, as defined in the format
            for zip described by PKWare.  The compression for this implementation 
            is based on the System.IO.Compression.DeflateStream base class in 
            the .NET Framework base class library, for v2.0 and later.</para>
            <para>NOTE: This Zip Library is based in whole or in part on the DotNetZip library
            located on CodePlex (http://www.codeplex.com/dotnetzip)</para>
            </summary>
        </member>
        <member name="M:HSS.IO.Zip.ZipFile.#ctor(System.String)">
             <summary>
             Creates a new ZipFile instance, using the specified ZipFileName for the filename. 
             The ZipFileName may be fully qualified.
             </summary>
             
             <remarks>
             <para>
             Applications can use this constructor to create a new ZipFile for writing, 
             or to slurp in an existing zip archive for read and write purposes.  
             </para>
             
             <para>
             To create a new zip archive, an application should call this constructor,
             passing the name of a file that does not exist.  Then the application can
             add directories or files to the ZipFile via <c>AddDirectory()</c>,
             <c>AddFile()</c>, <c>AddItem()</c> and then write the zip archive to the
             disk by calling <c>Save()</c>. The zip file is not actually written to
             the disk until the application calls <c>ZipFile.Save()</c>.  At that point
             the new zip file with the given name is created. 
             </para>
             
             <para>
             To read an existing zip archive, the application should call this constructor,
             passing the name of a valid zip file that does exist.  The file is then read into
             the <c>ZipFile</c> instance.  The app can then enumerate the entries or can modify
             the zip file, for example adding entries, removing entries, changing comments, and
             so on.  When reading an existing zip archive, the application may wish to
             explicitly specify that it is reading an existing zip file by using
             <c>ZipFile.Read()</c>.  On the other hand, this parameterized constructor allows
             applications to use the same code to add items to a zip archive, regardless of
             whether the zip file exists.
             </para>
             
             <para>
             To encrypt the data for the  files added to the ZipFile instance, set the Password
             property after creating the ZipFile instance.
             </para>
             
             </remarks>
            
             <exception cref="T:HSS.IO.Zip.ZipException">
             Thrown if zipFileName refers to an existing file that is not a valid zip file. 
             </exception>
            
             <example>
             This example shows how to create a zipfile, and add a few files into it. 
             <code>
             using (ZipFile zip = new ZipFile(args[0]))
             { 
               // Store all files found in the top level directory, into the zip archive.
               String[] filenames = System.IO.Directory.GetFiles(args[1]);
               foreach (String filename in filenames)
               {
                 Console.WriteLine("Adding {0}...", filename);
                 zip.AddFile(filename);
               }  
               zip.Save();
             }
             </code>
             
             <code lang="VB">
             Dim ZipToCreate As String = "ex1.zip"
             Dim DirectoryToZip As String = "c:\temp"
             Using zip As ZipFile = New ZipFile(ZipToCreate)
                 Dim filenames As String() = System.IO.Directory.GetFiles(DirectoryToZip)
                 Dim filename As String
                 For Each filename In filenames
                     Console.WriteLine("Adding {0}...", filename)
                     zip.AddFile(filename)
                 Next
                 zip.Save
             End Using
             </code>
             </example>
            
             <param name="zipFileName">The filename to use for the new zip archive.</param>
            
        </member>
        <member name="M:HSS.IO.Zip.ZipFile.#ctor">
             <summary>
             Create a zip file, without specifying a target filename or stream to save to. 
             </summary>
             
             <remarks>
             If you do eventually call <c>Save()</c>, you will need to have specified
             a zip filename at some point. Either as a parameter to <c>Save()</c> or 
             on the ZipFile object itself.
             </remarks>
             
             <example>
             This example creates a Zip archive called Backup.zip, containing all the files
             in the directory DirectoryToZip. Files within subdirectories are not zipped up.
             <code>
             using (ZipFile zip = new ZipFile())
             { 
               // Store all files found in the top level directory, into the zip archive.
               // note: this code does not recurse subdirectories!
               String[] filenames = System.IO.Directory.GetFiles(DirectoryToZip);
               foreach (String filename in filenames)
               {
                 Console.WriteLine("Adding {0}...", filename);
                 zip.AddFile(filename);
               }  
               zip.Save("Backup.zip");
             }
             </code>
            
             <code lang="VB">
             Using zip As New ZipFile
                 ' Store all files found in the top level directory, into the zip archive.
                 ' note: this code does not recurse subdirectories!
                 Dim filenames As String() = System.IO.Directory.GetFiles(DirectoryToZip)
                 Dim filename As String
                 For Each filename In filenames
                     Console.WriteLine("Adding {0}...", filename)
                     zip.AddFile(filename)
                 Next
                 zip.Save("Backup.zip")
             End Using
             </code>
             </example>
        </member>
        <member name="M:HSS.IO.Zip.ZipFile.#ctor(System.String,System.IO.TextWriter)">
             <summary>
             Creates a new ZipFile instance, using the specified ZipFileName for the filename. 
             The ZipFileName may be fully qualified.
             </summary>
            
             <remarks>
             <para>
             Applications can use this constructor to create a new ZipFile for writing, 
             or to slurp in an existing zip archive for read and write purposes.  
             </para>
            
             <para>
             To create a new zip archive, an application should call this constructor,
             passing the name of a file that does not exist.  Then the application can
             add directories or files to the ZipFile via <c>AddDirectory()</c>,
             <c>AddFile()</c>, <c>AddItem()</c> and then write the zip archive to the
             disk by calling <c>Save()</c>. The zip file is not actually written to
             the disk until the application calls <c>ZipFile.Save()</c>.  At that point
             the new zip file with the given name is created. 
             </para>
             
             <para>
             To read an existing zip archive, the application should call this constructor,
             passing the name of a valid zip file that does exist.  The file is then read into
             the <c>ZipFile</c> instance.  The app can then enumerate the entries or can modify
             the zip file, for example adding entries, removing entries, changing comments, and
             so on.  When reading an existing zip archive, the application may wish to
             explicitly specify that it is reading an existing zip file by using
             <c>ZipFile.Read()</c>.  On the other hand, this parameterized constructor allows
             applications to use the same code to add items to a zip archive, regardless of
             whether the zip file exists.
             </para>
            
             <para>
             This version of the constructor allows the caller to pass in a TextWriter, to which
             verbose messages will be written during extraction or creation of the zip archive.
             A console application may wish to pass System.Console.Out to get messages on the
             Console. A graphical or headless application may wish to capture the messages in a
             different <c>TextWriter</c>, for example, a <c>StringWriter</c>.
             </para>
             
             <para>
             To encrypt the data for the  files added to the ZipFile instance, set the Password
             property after creating the ZipFile instance.
             </para>
             
             </remarks>
            
             <exception cref="T:HSS.IO.Zip.ZipException">
             Thrown if zipFileName refers to an existing file that is not a valid zip file. 
             </exception>
            
             <example>
             <code>
             using (ZipFile zip = new ZipFile("Backup.zip", System.Console.Out))
             { 
               // Store all files found in the top level directory, into the zip archive.
               // note: this code does not recurse subdirectories!
               String[] filenames = System.IO.Directory.GetFiles(DirectoryToZip);
               foreach (String filename in filenames)
               {
                 Console.WriteLine("Adding {0}...", filename);
                 zip.AddFile(filename);
               }  
               zip.Save();
             }
             </code>
            
             <code lang="VB">
             Using zip As New ZipFile("Backup.zip", System.Console.Out)
                 ' Store all files found in the top level directory, into the zip archive.
                 ' note: this code does not recurse subdirectories!
                 Dim filenames As String() = System.IO.Directory.GetFiles(DirectoryToZip)
                 Dim filename As String
                 For Each filename In filenames
                     Console.WriteLine("Adding {0}...", filename)
                     zip.AddFile(filename)
                 Next
                 zip.Save
             End Using
             </code>
             </example>
             
             <param name="zipFileName">The filename to use for the new zip archive.</param>
             <param name="statusMessageWriter">A TextWriter to use for writing verbose status messages.</param>
        </member>
        <member name="M:HSS.IO.Zip.ZipFile.#ctor(System.IO.Stream)">
             <summary>
             Constructor to create an instance of ZipFile that writes Zip archives to a <c>System.IO.Stream</c>.
             </summary>
             
             <remarks>
             
             <para>
             Applications can use this constructor to create an instance of ZipFile 
             for writing to a stream. This is useful when zipping up content, but for any 
             reason it is not desirable to create a zip file in the filesystem itself. 
             </para>
            
             <para>
             Typically an application writing a zip archive in this manner will create and
             open a stream, then call this constructor, passing in the stream.  Then the app will add 
             directories or files to the ZipFile via <c>AddDirectory</c> or <c>AddFile</c> or <c>AddItem</c>.  The app
             will then write the zip archive to the memory stream by calling <c>Save()</c>. 
             </para>
            
             <para>
             The compressed (zipped) data is not actually written to the stream until the
             application calls <c>ZipFile.Save</c>.  This means the file data must be
             available at the time the <c>Save</c> method is invoked. 
             </para>
            
             <para>
             When using a filesystem file for the Zip output, it is possible to call
             <c>Save</c> multiple times on the ZipFile instance. With each call the zip content
             is written to the output file. When saving to a <c>Stream</c>, as you would do when you use this constructor, after the initial
             call to <c>Save</c>, additional calls to <c>Save</c> will throw. This is because the
             stream is assumed to be a write-only stream, and after the initial <c>Save</c>, it
             is not possible to seek backwards and "unwrite" the zip file data.
             </para>
            
             <para>
             Calling Save() on a ZipFile that has been created with this constructor will not
             result in the creation of a temporary zipfile in the filesystem.  
             </para>
            
             </remarks>
             
             <exception cref="T:System.ArgumentException">
             Thrown if the stream is not writable.  Seriously, think about it, dude. 
             You need a writable stream if you're going to extract zip content to it. 
             </exception>
            
             <example>
             <code>
                byte[] buffer= new byte[100000]; // 100k max
                System.IO.MemoryStream ms= new System.IO.MemoryStream(buffer);
            
                // write to the memory stream:
                try
                {
                  using (ZipFile zip = new ZipFile(ms,System.Console.Out))
                  {
                    zip.Comment= "This is the comment attached to the archive.";
                    zip.AddItem(directoryName);  // and recurse
                    zip.Save(); // write all the data to the stream and close it
                  }
                }
                catch (System.Exception ex1)
                {
                  System.Console.Error.WriteLine("exception: " + ex1);
                }
             </code>
             <code lang="VB">
               Dim buffer As Byte() = New Byte(100000) {}
               Dim ms As New System.IO.MemoryStream(buffer)
               ' write to the memory stream:
               Try 
                   Using zip As ZipFile = New ZipFile(ms, Console.Out)
                       zip.Comment = "This is the comment attached to the archive."
                       ' Add directory and recurse
                       zip.AddItem(NameOfDirectoryToZip)
                       ' now, write all the data to the stream and close it:
                       zip.Save
                   End Using
               Catch ex1 As Exception
                   Console.Error.WriteLine("exception: {0}", ex1.ToString())
               End Try
             </code>
             </example>
            
             <param name="outputStream">The <c>System.IO.Stream</c> to write to. It must be writable.</param>
        </member>
        <member name="M:HSS.IO.Zip.ZipFile.#ctor(System.IO.Stream,System.IO.TextWriter)">
             <summary>
             Constructor to create an instance of ZipFile that writes Zip archives to a stream.
             </summary>
             
             <remarks>
             <para>Applications can use this constructor to create an instance of ZipFile 
             for writing to a stream. This is useful when zipping up content, but for any 
             reason it is not desirable to create a zip file in the filesystem itself. 
             </para>
             <para>Typically an application writing a zip archive in this manner will create and
             open a stream, then call this constructor, passing in the stream.  Then the app will 
             add directories or files to the ZipFile via AddDirectory or AddFile or AddItem.  The 
             app will then write the zip archive to the memory stream by calling <c>Save</c>. The 
             compressed (zipped) data is not actually written to the stream until the application 
             calls <c>ZipFile.Save</c> .
             </para>
             <para>
             This version of the constructor allows the caller to pass in a TextWriter, to which  
             verbose messages will be written during creation of the zip archive.  A console 
             application may wish to pass System.Console.Out to get messages on the Console. 
             A graphical or headless application may wish to capture the messages in a different 
             TextWriter. 
             </para>
             </remarks>
            
             <exception cref="T:System.ArgumentException">
             Thrown if the stream is not writable. 
             You need to specify a writable stream if you're going to extract zip content to it. 
             </exception>
            
             <param name="outputStream">The outputStream to write to. It must be writable.</param>
             <param name="statusMessageWriter">A TextWriter to use for writing verbose status messages.</param>
        </member>
        <member name="M:HSS.IO.Zip.ZipFile.Finalize">
            <summary>
            This is the class Destructor, which gets called implicitly when the instance is destroyed.  
            Because the ZipFile type implements IDisposable, this method calls Dispose(false).  
            </summary>
        </member>
        <member name="M:HSS.IO.Zip.ZipFile.Dispose">
            <summary>
            Handles closing of the read and write streams associated
            to the ZipFile, if necessary.  The Dispose() method is generally 
            employed implicitly, via a using() {} statement. 
            </summary>
            <example>
            <code>
            using (ZipFile zip = ZipFile.Read(zipfile))
            {
              foreach (ZipEntry e in zip)
              {
                if (WantThisEntry(e.FileName)) 
                  zip.Extract(e.FileName, Console.OpenStandardOutput());
              }
            } // Dispose() is called implicitly here.
            </code>
            </example>
        </member>
        <member name="M:HSS.IO.Zip.ZipFile.Dispose(System.Boolean)">
            <summary>
            The Dispose() method.  It disposes any managed resources, 
            if the flag is set, then marks the instance disposed.
            This method is typically not called from application code.
            </summary>
            <param name="disposeManagedResources">indicates whether the method should dispose streams or not.</param>
        </member>
        <member name="F:HSS.IO.Zip.ZipFile.DefaultEncoding">
            <summary>
            The default text encoding used in zip archives.  It is numeric 437, also known as IBM437. 
            </summary>
            <seealso cref="P:HSS.IO.Zip.ZipFile.Encoding">Encoding</seealso>
        </member>
        <member name="M:HSS.IO.Zip.ZipFile.AddItem(System.String)">
             <summary>
             Adds an item, either a file or a directory, to a zip file archive.  
             </summary>
             
             <remarks>
             <para>
             If adding a directory, the add is recursive on all files and subdirectories 
             contained within it. 
             </para>
             <para>
             The name of the item may be a relative path or a fully-qualified path.
             The item added by this call to the ZipFile is not written to the zip file
             archive until the application calls Save() on the ZipFile. 
             </para>
             <para>
             The directory name used for the file within the archive is the same as
             the directory name (potentially a relative path) specified in the FileOrDirectoryName.
             </para>
             </remarks>
            
             <seealso cref="M:HSS.IO.Zip.ZipFile.AddFile(System.String)"/>
             <seealso cref="M:HSS.IO.Zip.ZipFile.AddDirectory(System.String)"/>
             <seealso cref="M:HSS.IO.Zip.ZipFile.UpdateItem(System.String)"/>
            
             <overloads>This method has two overloads.</overloads>
             <param name="fileOrDirectoryName">the name of the file or directory to add.</param>
             
        </member>
        <member name="M:HSS.IO.Zip.ZipFile.AddItem(System.String,System.String)">
             <summary>
             Adds an item, either a file or a directory, to a zip file archive, 
             explicitly specifying the directory path to be used in the archive. 
             </summary>
             
             <remarks>
             <para>
             If adding a directory, the add is recursive on all files and subdirectories 
             contained within it. 
             </para>
             <para>
             The name of the item may be a relative path or a fully-qualified path.
             The item added by this call to the ZipFile is not written to the zip file
             archive until the application calls Save() on the ZipFile. 
             </para>
             
             <para>
             This version of the method allows the caller to explicitly specify the 
             directory path to be used in the archive, which would override the 
             "natural" path of the filesystem file.
             </para>
             
             <para>
             Encryption will be used on the file data if the Password
             has been set on the ZipFile object, prior to calling this method.
             </para>
             
             </remarks>
             
             <exception cref="T:System.IO.FileNotFoundException">
             Thrown if the file or directory passed in does not exist. 
             </exception>
            
             <param name="fileOrDirectoryName">the name of the file or directory to add.</param>
             <param name="directoryPathInArchive">
             The name of the directory path to use within the zip archive. 
             This path need not refer to an extant directory in the current filesystem.
             If the files within the zip are later extracted, this is the path used for the extracted file. 
             Passing null (nothing in VB)) will use the path on the FileOrDirectoryName.  Passing the empty string ("")
             will insert the item at the root path within the archive. 
             </param>
             
             <seealso cref="M:HSS.IO.Zip.ZipFile.AddFile(System.String,System.String)"/>
             <seealso cref="M:HSS.IO.Zip.ZipFile.AddDirectory(System.String,System.String)"/>
             <seealso cref="M:HSS.IO.Zip.ZipFile.UpdateItem(System.String,System.String)"/>
            
             <example>
             This example shows how to zip up a set of files into a flat hierarchy, 
             regardless of where in the filesystem the files originated.
             <code>
             String[] itemnames= { 
               "c:\\temp\\Readme.txt",
               "MyProposal.docx",
               "SupportFiles",  // a directory
               "images\\Image1.jpg"
             };
            
             try
             {
               using (ZipFile zip = new ZipFile(ZipToCreate,System.Console.Out))
               {
                 for (int i = 1; i &lt; itemnames.Length; i++)
                 {
                   // will add Files or Dirs, recurses and flattens subdirectories
                   zip.AddItem(itemnames[i],"flat"); 
                 }
                 zip.Save();
               }
             }
             catch (System.Exception ex1)
             {
               System.Console.Error.WriteLine("exception: {0}", ex1);
             }
             </code>
            
             <code lang="VB">
               Dim itemnames As String() = _
                 New String() { "c:\temp\Readme.txt", _
                                "MyProposal.docx", _
                                "SupportFiles", _
                                "images\Image1.jpg" }
               Try 
                   Using zip As New ZipFile(ZipToCreate, Console.Out)
                       Dim i As Integer
                       For i = 1 To itemnames.Length - 1
                           ' will add Files or Dirs, recursing and flattening subdirectories.
                           zip.AddItem(itemnames(i), "flat")
                       Next i
                       zip.Save
                   End Using
               Catch ex1 As Exception
                   Console.Error.WriteLine("exception: {0}", ex1.ToString())
               End Try
             </code>
             </example>
        </member>
        <member name="M:HSS.IO.Zip.ZipFile.AddFile(System.String)">
             <summary>
             Adds a File to a Zip file archive. 
             </summary>
             <remarks>
             The file added by this call to the ZipFile is not written to the zip file
             archive until the application calls Save() on the ZipFile. 
             </remarks>
             
             <example>
             <para>
             In this example, three files are added to a Zip archive. The ReadMe.txt file
             will be placed in the root of the archive. The .png file will be placed in a folder 
             within the zip called photos\personal.  The pdf file will be included into a
             folder within the zip called Desktop.
             </para>
             <code>
                try
                {
                  using (ZipFile zip = new ZipFile("test2.zip",System.Console.Out))
                  {
                    zip.AddFile("c:\\photos\\personal\\7440-N49th.png");
                    zip.AddFile("c:\\Desktop\\2005_Annual_Report.pdf");
                    zip.AddFile("ReadMe.txt");
            
                    zip.Save();
                  }
                }
                catch (System.Exception ex1)
                {
                  System.Console.Error.WriteLine("exception: " + ex1);
                }
             </code>
             
             <code lang="VB">
              Try 
                   Using zip As ZipFile = New ZipFile("test2.zip", Console.Out)
                       zip.AddFile("c:\photos\personal\7440-N49th.png")
                       zip.AddFile("c:\Desktop\2005_Annual_Report.pdf")
                       zip.AddFile("ReadMe.txt")
                       zip.Save
                   End Using
               Catch ex1 As Exception
                   Console.Error.WriteLine("exception: {0}", ex1.ToString)
               End Try
             </code>
             </example>
             
             <overloads>This method has two overloads.</overloads>
             
             <seealso cref="M:HSS.IO.Zip.ZipFile.AddItem(System.String)"/>
             <seealso cref="M:HSS.IO.Zip.ZipFile.AddDirectory(System.String)"/>
             <seealso cref="M:HSS.IO.Zip.ZipFile.UpdateFile(System.String)"/>
            
             <param name="fileName">
             The name of the file to add. It should refer to a file in the filesystem.  
             The name of the file may be a relative path or a fully-qualified path. 
             </param>
             <returns>The ZipEntry corresponding to the File added.</returns>
        </member>
        <member name="M:HSS.IO.Zip.ZipFile.AddFile(System.String,System.String)">
             <summary>
             Adds a File to a Zip file archive, potentially overriding the path to be used
             within the zip archive.
             </summary>
             
             <remarks>
             <para>
             The file added by this call to the ZipFile is not written to the zip file
             archive until the application calls Save() on the ZipFile. 
             </para>
             
             <para>
             This version of the method allows the caller to explicitly specify the 
             directory path to be used in the archive. 
             </para>
             
             </remarks>
             
             <example>
             <para>
             In this example, three files are added to a Zip archive. The ReadMe.txt file
             will be placed in the root of the archive. The .png file will be placed in a folder 
             within the zip called images.  The pdf file will be included into a
             folder within the zip called files\documents, and will be encrypted with the 
             given password.
             </para>
             <code>
             try
             {
               using (ZipFile zip = new ZipFile("Archive.zip",System.Console.Out))
               {
                 zip.AddFile("c:\\datafiles\\ReadMe.txt", "");
                 zip.AddFile("c:\\photos\\personal\\7440-N49th.png", "images");
                 zip.Password = "EncryptMe!";
                 zip.AddFile("c:\\Desktop\\2005_Annual_Report.pdf", "files\\documents");
                 zip.Save();
               }
             }
             catch (System.Exception ex1)
             {
               System.Console.Error.WriteLine("exception: {0}", ex1);
             }
             </code>
             
             <code lang="VB">
               Try 
                   Using zip As ZipFile = New ZipFile("Archive.zip", Console.Out)
                       zip.AddFile("c:\datafiles\ReadMe.txt", "")
                       zip.AddFile("c:\photos\personal\7440-N49th.png", "images")
                       zip.Password = "EncryptMe!"
                       zip.AddFile("c:\Desktop\2005_Annual_Report.pdf", "files\documents")
                       zip.Save
                   End Using
               Catch ex1 As Exception
                   Console.Error.WriteLine("exception: {0}", ex1)
               End Try
             </code>
             </example>
             
             <seealso cref="M:HSS.IO.Zip.ZipFile.AddItem(System.String,System.String)"/>
             <seealso cref="M:HSS.IO.Zip.ZipFile.AddDirectory(System.String,System.String)"/>
             <seealso cref="M:HSS.IO.Zip.ZipFile.UpdateFile(System.String,System.String)"/>
            
             <param name="fileName">
             The name of the file to add.  The name of the file may be a relative path or 
             a fully-qualified path.
             </param>
            
             <param name="directoryPathInArchive">
             Specifies a directory path to use to override any path in the FileName.
             This path may, or may not, correspond to a real directory in the current filesystem.
             If the files within the zip are later extracted, this is the path used for the extracted file. 
             Passing null (nothing in VB) will use the path on the FileName, if any.  Passing the empty string ("")
             will insert the item at the root path within the archive. 
             </param>
            
             <returns>The ZipEntry corresponding to the file added.</returns>
        </member>
        <member name="M:HSS.IO.Zip.ZipFile.UpdateFile(System.String)">
             <summary>
             Adds or Updates a File in a Zip file archive.
             </summary>
             
             <remarks>
             <para>
             This method adds a file to a zip archive, or, if the file already exists in the zip archive, 
             this method Updates the content of that given filename in the zip archive.
             </para>
            
             <para>
             Upon success, there is no way for the application to learn whether the file was added or updated. 
             </para>
            
             </remarks>
            
             <example>
             This example shows how to Update an existing entry in a zipfile. The first call to 
             UpdateFile adds the file to the newly-created zip archive.  The second 
             call to UpdateFile updates the content for that file in the zip archive.
             <code>
             using (ZipFile zip1 = new ZipFile())
             {
               // UpdateFile might more accurately be called "AddOrUpdateFile"
               zip1.UpdateFile("MyDocuments\\Readme.txt", "");
               zip1.UpdateFile("CustomerList.csv", "");
               zip1.Comment = "This zip archive has been created.";
               zip1.Save("Content.zip");
             }
             
             using (ZipFile zip2 = ZipFile.Read("Content.zip"))
             {
               zip2.UpdateFile("Updates\\Readme.txt", "");
               zip2.Comment = "This zip archive has been updated: The Readme.txt file has been changed.";
               zip2.Save();
             }
            
             </code>
             <code lang="VB">
               Using zip1 As New ZipFile
                   ' UpdateFile might more accurately be called "AddOrUpdateFile"
                   zip1.UpdateFile("MyDocuments\Readme.txt", "")
                   zip1.UpdateFile("CustomerList.csv", "")
                   zip1.Comment = "This zip archive has been created."
                   zip1.Save("Content.zip")
               End Using
            
               Using zip2 As ZipFile = ZipFile.Read("Content.zip")
                   zip2.UpdateFile("Updates\Readme.txt", "")
                   zip2.Comment = "This zip archive has been updated: The Readme.txt file has been changed."
                   zip2.Save
               End Using
             </code>
             </example>
            
             <seealso cref="M:HSS.IO.Zip.ZipFile.AddFile(System.String)"/>
             <seealso cref="M:HSS.IO.Zip.ZipFile.UpdateDirectory(System.String)"/>
             <seealso cref="M:HSS.IO.Zip.ZipFile.UpdateItem(System.String)"/>
            
             <param name="fileName">
             The name of the file to add or update. It should refer to a file in the filesystem.  
             The name of the file may be a relative path or a fully-qualified path. 
             </param>
            
             <returns>The ZipEntry corresponding to the File that was added or updated.</returns>
        </member>
        <member name="M:HSS.IO.Zip.ZipFile.UpdateFile(System.String,System.String)">
             <summary>
             Adds or Updates a File in a Zip file archive.
             </summary>
             
             <remarks>
             <para>
             This method adds a file to a zip archive, or, if the file already exists in the zip archive, 
             this method Updates the content of that given filename in the zip archive.
             </para>
             
             <para>
             This version of the method allows the caller to explicitly specify the 
             directory path to be used in the archive.  The entry to be added or updated is found by 
             using the specified directory path, combined with the basename of the specified 
             filename. 
             </para>
             
             <para>
             Upon success, there is no way for the application to learn whether the file was added or updated. 
             </para>
             </remarks>
             
             <seealso cref="M:HSS.IO.Zip.ZipFile.AddFile(System.String,System.String)"/>
             <seealso cref="M:HSS.IO.Zip.ZipFile.UpdateDirectory(System.String,System.String)"/>
             <seealso cref="M:HSS.IO.Zip.ZipFile.UpdateItem(System.String,System.String)"/>
            
             <param name="fileName">
             The name of the file to add or update. It should refer to a file in the filesystem.  
             The name of the file may be a relative path or a fully-qualified path. 
             </param>
            
             <param name="directoryPathInArchive">
             Specifies a directory path to use to override any path in the FileName.
             This path may, or may not, correspond to a real directory in the current filesystem.
             If the files within the zip are later extracted, this is the path used for the extracted file. 
             Passing null (nothing in VB) will use the path on the FileName, if any.  Passing the empty string ("")
             will insert the item at the root path within the archive. 
             </param>
            
             <returns>The ZipEntry corresponding to the File that was added or updated.</returns>
        </member>
        <member name="M:HSS.IO.Zip.ZipFile.UpdateDirectory(System.String)">
             <summary>
             Add or Update a Directory in a zip archive.
             If the directory has already been added to the archive,
             its contents are updated.  If not, then the directory is added.
             </summary>
            
             <remarks>
             If the specified directory does not exist in the archive, then this method is equivalent to
             calling AddDirectory().  If the specified directory already exists in the archive, then this 
             method updates any existing entries, and adds any new entries. Any entries that are in the 
             zip archive but not in the specified directory, are left alone.  In other words, the contents of 
             the zip file is a union of the previous contents and the new files.
             </remarks>
            
             <seealso cref="M:HSS.IO.Zip.ZipFile.UpdateFile(System.String)"/>
             <seealso cref="M:HSS.IO.Zip.ZipFile.AddDirectory(System.String)"/>
             <seealso cref="M:HSS.IO.Zip.ZipFile.UpdateItem(System.String)"/>
            
             <param name="directoryName">The path to the directory to be added to the zip archive, 
             or updated in the zip archive.</param>
        </member>
        <member name="M:HSS.IO.Zip.ZipFile.UpdateDirectory(System.String,System.String)">
             <summary>
             Add or Update a directory in the zip archive at the specified root directory in the archive.  
             If the directory has already been added to the archive,
             its contents are updated.  If not, then the directory is added.
             </summary>
            
             <remarks>
             If the specified directory does not exist in the archive, then this method is equivalent to
             calling AddDirectory().  If the specified directory already exists in the archive, then this 
             method updates any existing entries, and adds any new entries. Any entries that are in the 
             zip archive but not in the specified directory, are left alone.  In other words, the contents of 
             the zip file is a union of the previous contents and the new files.
             </remarks>
            
             <seealso cref="M:HSS.IO.Zip.ZipFile.UpdateFile(System.String,System.String)"/>
             <seealso cref="M:HSS.IO.Zip.ZipFile.AddDirectory(System.String,System.String)"/>
             <seealso cref="M:HSS.IO.Zip.ZipFile.UpdateItem(System.String,System.String)"/>
            
             <param name="directoryName">The path to the directory to be added to the zip archive, 
             or updated in the zip archive.</param>
            
             <param name="directoryPathInArchive">
             Specifies a directory path to use to override any path in the ItemName.
             This path may, or may not, correspond to a real directory in the current filesystem.
             If the files within the zip are later extracted, this is the path used for the extracted file. 
             Passing null (nothing in VB) will use the path on the FileName, if any.  Passing the empty string ("")
             will insert the item at the root path within the archive. 
             </param>
             
        </member>
        <member name="M:HSS.IO.Zip.ZipFile.UpdateItem(System.String)">
             <summary>
             Add or Update a File or Directory in the zip archive. This
             is useful when the application is not sure or does not care
             if the entries in the existing zip archive already exist.
             </summary>
            
             <seealso cref="M:HSS.IO.Zip.ZipFile.AddItem(System.String)"/>
             <seealso cref="M:HSS.IO.Zip.ZipFile.UpdateFile(System.String)"/>
             <seealso cref="M:HSS.IO.Zip.ZipFile.UpdateDirectory(System.String)"/>
            
             <param name="itemName">the path to the file or directory to be added or updated.</param>
        </member>
        <member name="M:HSS.IO.Zip.ZipFile.UpdateItem(System.String,System.String)">
             <summary>
             Add or Update a File or Directory.  This is useful when the application is not sure or does not 
             care if the entries in the existing zip archive already exist.  
             </summary>
            
             <remarks>
             <para>
             This version of the method allows the caller to explicitly specify the 
             directory path to be used for the item being added to the archive.  The entry or entries 
             that are added or updated will use the specified <c>DirectoryPathInArchive</c>. Extracting
             the entry from the archive will result in a file stored in that directory path. 
             </para>
             </remarks>
            
             <seealso cref="M:HSS.IO.Zip.ZipFile.AddItem(System.String,System.String)"/>
             <seealso cref="M:HSS.IO.Zip.ZipFile.UpdateFile(System.String,System.String)"/>
             <seealso cref="M:HSS.IO.Zip.ZipFile.UpdateDirectory(System.String,System.String)"/>
            
             <param name="itemName">The path for the File or Directory to be added or updated.</param>
             <param name="directoryPathInArchive">
             Specifies a directory path to use to override any path in the ItemName.
             This path may, or may not, correspond to a real directory in the current filesystem.
             If the files within the zip are later extracted, this is the path used for the extracted file. 
             Passing null (nothing in VB) will use the path on the FileName, if any.  Passing the empty string ("")
             will insert the item at the root path within the archive. 
             </param>
        </member>
        <member name="M:HSS.IO.Zip.ZipFile.AddFileStream(System.String,System.String,System.IO.Stream)">
             <summary>
             Uses the given stream as input to create an entry in the ZipFile, with the 
             given FileName and given Directory Path.  
             </summary>
            
             <remarks>
             <para>
             The stream must remain open and readable at least through the call to 
             <c>ZipFile.Save</c>.
             </para>
             <para>
             Encryption will be used on the stream data when saving the 
             ZipFile, if the Password is set on the ZipFile object prior to calling
             this method.</para>
             </remarks>
            
             <example>
             <code lang="C#">
             String ZipToCreate = "Content.zip";
             String FileNameInArchive = "Content-From-Stream.bin";
             using (ZipFile zip = new ZipFile(ZipToCreate))
             {
               ZipEntry entry= zip.AddFileStream(FileNameInArchive, "basedirectory", StreamToRead);
               entry.Comment = "The content for entry in the zip file was obtained from a stream";
               zip.AddFile("Readme.txt");
               zip.Save();
             }
             
             </code>
             <code lang="VB">
             Dim ZipToCreate As String = "Content.zip"
             Dim FileNameInArchive As String = "Content-From-Stream.bin"
             Using zip As ZipFile = New ZipFile(ZipToCreate)
               Dim entry as ZipEntry = zip.AddFileStream(FileNameInArchive, "basedirectory", Me.StreamToRead)
               entry.Comment = "The content for entry in the zip file was obtained from a stream"
               zip.AddFile("Readme.txt")
               zip.Save
             End Using
             </code>
             </example>
             <seealso cref="M:HSS.IO.Zip.ZipFile.UpdateFileStream(System.String,System.String,System.IO.Stream)"/>
            
             <param name="fileName">FileName which is shown in the ZIP File</param>
             <param name="directoryPathInArchive">
             Specifies a directory path to use to override any path in the ItemName.
             This path may, or may not, correspond to a real directory in the current filesystem.
             If the files within the zip are later extracted, this is the path used for the extracted file. 
             Passing null (nothing in VB) will use the path on the FileName, if any.  Passing the empty string ("")
             will insert the item at the root path within the archive. 
             </param>
             <param name="stream">the input stream from which to grab content for the file</param>
             <returns>The ZipEntry added.</returns>
        </member>
        <member name="M:HSS.IO.Zip.ZipFile.AddFileFromString(System.String,System.String,System.String)">
            <summary>
            Adds an entry into the zip archive using the given filename and directory path within the archive,
            and the given content for the file.  No file is created in the filesystem.  
            </summary>
            <param name="content">The content of the file, should it be extracted from the zip.</param>
            <param name="fileName">The filename to use within the archive.</param>
            <param name="directoryPathInArchive">
            Specifies a driectory path to use to override any path in the ItemName.
            This path may, or may not, correspond to a real directory in the current filesystem.
            If the files within the zip are later extracted, this is the path used for the extracted file. 
            Passing null (nothing in VB) will use the path on the FileName, if any.  Passing the empty string ("")
            will insert the item at the root path within the archive. 
            </param>
            <returns>The ZipEntry added.</returns>
            
            <example>
            This example shows how to add an entry to the zipfile, using a string as content for that entry. 
            <code lang="C#">
            string Content = "This string will be the content of the Readme.txt file in the zip archive.";
            using (ZipFile zip1 = new ZipFile())
            {
              zip1.AddFile("MyDocuments\\Resume.doc", "files");
              zip1.AddFileFromString("Readme.txt", "", Content); 
              zip1.Comment = "This zip file was created at " + System.DateTime.Now.ToString("G");
              zip1.Save("Content.zip");
            }
            
            </code>
            <code lang="VB">
            Public Sub Run()
              Dim Content As String = "This string will be the content of the Readme.txt file in the zip archive."
              Using zip1 As ZipFile = New ZipFile
                zip1.AddFileFromString("Readme.txt", "", Content)
                zip1.AddFile("MyDocuments\Resume.doc", "files")
                zip1.Comment = ("This zip file was created at " &amp; DateTime.Now.ToString("G"))
                zip1.Save("Content.zip")
              End Using
            End Sub
            </code>
            </example>
        </member>
        <member name="M:HSS.IO.Zip.ZipFile.UpdateFileStream(System.String,System.String,System.IO.Stream)">
             <summary>
             Updates the given entry in the zipFile, using the given stream as input, and the
             given FileName and given Directory Path.  Encryption will be used on the 
             stream data if the Password is set on the ZipFile object, prior to calling
             this method.
             </summary>
            
             <remarks>
             The stream must remain open and readable at least through the call to 
             <c>ZipFile.Save</c>.
             </remarks>
            
             <seealso cref="M:HSS.IO.Zip.ZipFile.AddFileStream(System.String,System.String,System.IO.Stream)"/>
            
             <param name="fileName">FileName which is shown in the ZIP File</param>
             <param name="directoryPathInArchive">The root path to be used in the ZIP archive, 
             for the entry added from the stream.</param>
             <param name="stream">The Input Stream to read file data from.</param>
             <returns>The ZipEntry added.</returns>
        </member>
        <member name="M:HSS.IO.Zip.ZipFile.AddDirectory(System.String)">
             <summary>
             Adds the contents of a filesystem directory to a Zip file archive. 
             </summary>
             
             <remarks>
             
             <para>
             The name of the directory may be 
             a relative path or a fully-qualified path. Any files within the named 
             directory are added to the archive.  Any subdirectories within the named
             directory are also added to the archive, recursively. 
             </para>
             
             <para>
             Top-level entries in the named directory will appear as top-level 
             entries in the zip archive.  Entries in subdirectories in the named 
             directory will result in entries in subdirectories in the zip archive.
             </para>
             
             <para>
             If you want the entries to appear in a containing directory in the zip
             archive itself, then you should call the AddDirectory() overload that allows
             you to explicitly specify a containing directory.
             </para>
             
             </remarks>
             
             <seealso cref="M:HSS.IO.Zip.ZipFile.AddItem(System.String)"/>
             <seealso cref="M:HSS.IO.Zip.ZipFile.AddFile(System.String)"/>
             <seealso cref="M:HSS.IO.Zip.ZipFile.UpdateDirectory(System.String)"/>
             <seealso cref="M:HSS.IO.Zip.ZipFile.AddDirectory(System.String,System.String)"/>
            
             <overloads>This method has 2 overloads.</overloads>
             
             <param name="directoryName">The name of the directory to add.</param>
        </member>
        <member name="M:HSS.IO.Zip.ZipFile.AddDirectory(System.String,System.String)">
             <summary>
             Adds the contents of a filesystem directory to a Zip file archive, 
             overriding the path to be used for entries in the archive. 
             </summary>
             
             <remarks>
             <para>
             The name of the directory may be a relative path or a fully-qualified
             path. The add operation is recursive, so that any files or subdirectories
             within the name directory are also added to the archive.
             </para>
             </remarks>
             
             <example>
             <para>
             In this code, calling the ZipUp() method with a value of "c:\temp" for the
             directory parameter will result in a zip file structure in which all entries
             are contained in a toplevel "temp" directory.
             </para>
            
             <code lang="C#">
             public void ZipUp(string targetZip, string directory)
             {
               using (var zip = new ZipFile())
               {
                 zip.AddDirectory(directory, System.IO.Path.GetFileName(directory));
                 zip.Save(targetZip);
               }
             }
             </code>
             </example>
             
             <seealso cref="M:HSS.IO.Zip.ZipFile.AddItem(System.String,System.String)"/>
             <seealso cref="M:HSS.IO.Zip.ZipFile.AddFile(System.String,System.String)"/>
             <seealso cref="M:HSS.IO.Zip.ZipFile.UpdateDirectory(System.String,System.String)"/>
            
             <param name="directoryName">The name of the directory to add.</param>
             
             <param name="directoryPathInArchive">
             Specifies a directory path to use to override any path in the DirectoryName.
             This path may, or may not, correspond to a real directory in the current filesystem.
             If the zip is later extracted, this is the path used for the extracted file or directory. 
             Passing null (nothing in VB) or the empty string ("")
             will insert the items at the root path within the archive. 
             </param>
             
        </member>
        <member name="M:HSS.IO.Zip.ZipFile.AddDirectoryByName(System.String)">
             <summary>
             Creates a directory in the zip archive.  
             </summary>
             
             <remarks>
             
             <para>
             Use this when you want to create a directory in the archive but there is no
             corresponding filesystem representation for that directory.
             </para>
            
             <para>
             You will probably not need to do this in your code. One of the only times
             you will want to do this is if you want an empty directory in the zip
             archive.  If you add a file to a zip archive that is stored within a
             multi-level directory, all of the directory tree is implicitly created in
             the zip archive.  
             </para>
             
             </remarks>
             
             <param name="directoryNameInArchive">
             The name of the directory to create in the archive.
             </param>
        </member>
        <member name="M:HSS.IO.Zip.ZipFile.Save">
             <summary>
             Saves the Zip archive, using the name given when the ZipFile was instantiated. 
             </summary>
            
             <remarks>
             <para>
             The zip file is written to storage only when the caller calls <c>Save</c>.  
             The Save operation writes the zip content to a temporary file. 
             Then, if the zip file already exists (for example when adding an item to a zip archive)
             this method will replace the existing zip file with this temporary file.
             If the zip file does not already exist, the temporary file is renamed 
             to the desired name.  
             </para>
            
             <para>
             When using a filesystem file for the Zip output, it is possible to call
             <c>Save</c> multiple times on the ZipFile instance. With each call the zip content
             is written to the output file. When saving to a <c>Stream</c>, after the initial
             call to <c>Save</c>, additional calls to <c>Save</c> will throw. This is because the
             stream is assumed to be a write-only stream, and after the initial <c>Save</c>, it
             is not possible to seek backwards and "unwrite" the zip file data.
             </para>
            
             <para>
             Data for entries that have been added to the <c>ZipFile</c> instance is written
             to the output when the <c>Save</c> method is called. This means that the input
             streams for those entries must be available at the time the application
             calls <c>Save</c>.  If, for example, the application adds entries with
             <c>AddFileStream</c> using a dynamically-allocated <c>MemoryStream</c>,
             the memory stream must not have been disposed before the call to <c>Save</c>.
             </para>
            
             <para>
             When using the zip library within an ASP.NET application, you may wish to set the
             <c>TempFileFolder</c> property on the <c>ZipFile</c> instance before calling Save().
             </para>
             </remarks>
            
             <seealso cref="M:HSS.IO.Zip.ZipFile.AddFileStream(System.String,System.String,System.IO.Stream)"/>
            
             <exception cref="T:HSS.IO.Zip.BadStateException">
             Thrown if you haven't specified a location or stream for saving the zip,
             either in the constructor or by setting the Name property. 
             </exception>
            
        </member>
        <member name="M:HSS.IO.Zip.ZipFile.Save(System.String)">
             <summary>
             Save the file to a new zipfile, with the given name. 
             </summary>
             
             <remarks>
             <para>
             This is handy when reading a zip archive from a stream 
             and you want to modify the archive (add a file, change a 
             comment, etc) and then save it to a file. 
             </para>
             <para>
             It also works if you create a new ZipFile for writing to a 
             stream, and then you also want to write it to a filesystem file. 
             In that case, call the Save() method, and then also call this method with
             a filename. 
             </para>
             </remarks>
             
             <exception cref="T:System.ArgumentException">
             Thrown if you specify a directory for the filename.
             </exception>
            
             <param name="zipFileName">
             The name of the zip archive to save to. Existing files will 
             be overwritten with great prejudice.
             </param>
        </member>
        <member name="M:HSS.IO.Zip.ZipFile.OnSaveProgress(System.Int32,System.String)">
            <summary>
            Fires the <see cref="E:HSS.IO.Zip.ZipFile.SaveProgress"/> method.
            </summary>
        </member>
        <member name="M:HSS.IO.Zip.ZipFile.OnExtractProgress(System.Int32,System.String,System.String,System.Boolean)">
            <summary>
            Fires the <see cref="E:HSS.IO.Zip.ZipFile.ExtractProgress"/> method.
            </summary>
        </member>
        <member name="M:HSS.IO.Zip.ZipFile.IsZipFile(System.String)">
            <summary>
            Checks the given file to see if it appears to be a valid zip file.
            </summary>
            <remarks>
            This method opens the file, and reads in the zip header, as well as the
            zip directory structure.  If everything succeeds, then the method
            returns true.  If anything fails - for example if an incorrect signature
            is found, the the method returns false.  This method also returns false
            (no exception) for a file that does not exist.  Because this method does
            not actually read in the zip content, decrypt, and check CRCs, it is
            possible for this method to return true in the case the zip file is
            corrupted.
            </remarks>
            <param name="fileName">The file to check.</param>
            <returns>true if the file appears to be a zip file.</returns>
        </member>
        <member name="M:HSS.IO.Zip.ZipFile.Read(System.String)">
             <summary>
             Reads a zip file archive and returns the instance.  
             </summary>
             
             <remarks>
             <para>
             The stream is read using the default <c>System.Text.Encoding</c>, which is the <c>IBM437</c> codepage.  
             </para>
             </remarks>
             <exception cref="T:System.Exception">
             Thrown if the ZipFile cannot be read. The implementation of this 
             method relies on <c>System.IO.File.OpenRead</c>, which can throw
             a variety of exceptions, including specific exceptions if a file
             is not found, an unauthorized access exception, exceptions for
             poorly formatted filenames, and so on. 
             </exception>
             
             <param name="zipFileName">
             The name of the zip archive to open.  
             This can be a fully-qualified or relative pathname.
             </param>
             
             <overloads>This method has a bunch of interesting overloads. They are all static (Shared in VB)</overloads>
            
             <returns>The instance read from the zip archive.</returns>
             
        </member>
        <member name="M:HSS.IO.Zip.ZipFile.Read(System.String,System.IO.TextWriter)">
             <summary>
             Reads a zip file archive using the specified text encoding, and returns the instance.  
             </summary>
             
             <remarks>
             <para>
             This version of the method allows the caller to pass in a <c>TextWriter</c>.  
             The ZipFile is read in using the default IBM437 encoding for entries where no
             encoding is specified.
             </para>
             <para>
             The stream is read using the default <c>System.Text.Encoding</c>, which is the <c>IBM437</c> codepage.  
             </para>
             </remarks>
             
             <example>
             <code lang="C#">
             var sw = new System.IO.StringWriter();
             using (ZipFile zip =  ZipFile.Read("PackedDocuments.zip", sw))
             {
               var Threshold = new DateTime(2007,7,4);
               // We cannot remove the entry from the list, within the context of 
               // an enumeration of said list.
               // So we add the doomed entry to a list to be removed later.
               // pass 1: mark the entries for removal
               var MarkedEntries = new System.Collections.Generic.List&lt;ZipEntry&gt;();
               foreach (ZipEntry e in zip)
               {
                 if (e.LastModified &lt; Threshold)
                   MarkedEntries.Add(e);
               }
               // pass 2: actually remove the entry. 
               foreach (ZipEntry zombie in MarkedEntries)
                  zip.RemoveEntry(zombie);
               zip.Comment = "This archive has been updated.";
               zip.Save();
             }
             // can now use contents of sw, eg store in an audit log
             </code>
            
             <code lang="VB">
               Dim sw As New System.IO.StringWriter
               Using zip As ZipFile = ZipFile.Read("PackedDocuments.zip", sw)
                   Dim Threshold As New DateTime(2007, 7, 4)
                   ' We cannot remove the entry from the list, within the context of 
                   ' an enumeration of said list.
                   ' So we add the doomed entry to a list to be removed later.
                   ' pass 1: mark the entries for removal
                   Dim MarkedEntries As New System.Collections.Generic.List(Of ZipEntry)
                   Dim e As ZipEntry
                   For Each e In zip
                       If (e.LastModified &lt; Threshold) Then
                           MarkedEntries.Add(e)
                       End If
                   Next
                   ' pass 2: actually remove the entry. 
                   Dim zombie As ZipEntry
                   For Each zombie In MarkedEntries
                       zip.RemoveEntry(zombie)
                   Next
                   zip.Comment = "This archive has been updated."
                   zip.Save
               End Using
               ' can now use contents of sw, eg store in an audit log
             </code>
             </example>
             
             <exception cref="T:System.Exception">
             Thrown if the zipfile cannot be read. The implementation of this 
             method relies on <c>System.IO.File.OpenRead</c>, which can throw
             a variety of exceptions, including specific exceptions if a file
             is not found, an unauthorized access exception, exceptions for
             poorly formatted filenames, and so on. 
             </exception>
             
             <param name="zipFileName">
             The name of the zip archive to open.  
             This can be a fully-qualified or relative pathname.
             </param>
             
             <param name="statusMessageWriter">
             The <c>System.IO.TextWriter</c> to use for writing verbose status messages during operations
             on the zip archive.  A console application may wish to pass <c>System.Console.Out</c> to get 
             messages on the Console. A graphical or headless application may wish to capture the messages 
             in a different <c>TextWriter</c>, such as a <c>System.IO.StringWriter</c>. 
             </param>
             
             <returns>The instance read from the zip archive.</returns>
             
        </member>
        <member name="M:HSS.IO.Zip.ZipFile.Read(System.String,System.Text.Encoding)">
            <summary>
            Reads a zip file archive using the specified text encoding, and returns the instance.  
            </summary>
            
            <remarks>
            <para>
            This version of the method allows the caller to pass in an <c>Encoding</c>.  
            The ZipFile is read in using the specified encoding for entries where no
            encoding is specified.
            </para>
            <para>
            See the <see cref="M:HSS.IO.Zip.ZipFile.Read(System.String,System.IO.TextWriter)"/> overload for a code example.
            </para>
            </remarks>
            
            <exception cref="T:System.Exception">
            Thrown if the zipfile cannot be read. The implementation of this 
            method relies on <c>System.IO.File.OpenRead</c>, which can throw
            a variety of exceptions, including specific exceptions if a file
            is not found, an unauthorized access exception, exceptions for
            poorly formatted filenames, and so on. 
            </exception>
            
            <param name="zipFileName">
            The name of the zip archive to open.  
            This can be a fully-qualified or relative pathname.
            </param>
            
            <param name="encoding">
            The <c>System.Text.Encoding</c> to use when reading in the zip archive. Be careful specifying the
            encoding.  If the value you use here is not the same as the Encoding used when the zip archive was 
            created (possibly by a different archiver) you will get unexpected results.  
            </param>
            
            <returns>The instance read from the zip archive.</returns>
            
        </member>
        <member name="M:HSS.IO.Zip.ZipFile.Read(System.String,System.IO.TextWriter,System.Text.Encoding)">
            <summary>
            Reads a zip file archive using the specified text encoding, and returns the instance.  
            </summary>
            
            <remarks>
            <para>
            This version of the method allows the caller to pass in a <c>TextWriter</c> and an <c>Encoding</c>.  
            </para>
            <para>
            See the <see cref="M:HSS.IO.Zip.ZipFile.Read(System.String,System.IO.TextWriter)"/> overload for a code example.
            </para>
            </remarks>
            
            <exception cref="T:System.Exception">
            Thrown if the zipfile cannot be read. The implementation of this 
            method relies on <c>System.IO.File.OpenRead</c>, which can throw
            a variety of exceptions, including specific exceptions if a file
            is not found, an unauthorized access exception, exceptions for
            poorly formatted filenames, and so on. 
            </exception>
            
            <param name="zipFileName">
            The name of the zip archive to open.  
            This can be a fully-qualified or relative pathname.
            </param>
            
            <param name="statusMessageWriter">
            The <c>System.IO.TextWriter</c> to use for writing verbose status messages during operations
            on the zip archive.  A console application may wish to pass <c>System.Console.Out</c> to get 
            messages on the Console. A graphical or headless application may wish to capture the messages 
            in a different <c>TextWriter</c>, such as a <c>System.IO.StringWriter</c>. 
            </param>
            
            <param name="encoding">
            The <c>System.Text.Encoding</c> to use when reading in the zip archive. Be careful specifying the
            encoding.  If the value you use here is not the same as the Encoding used when the zip archive was 
            created (possibly by a different archiver) you will get unexpected results.  
            </param>
            
            <returns>The instance read from the zip archive.</returns>
            
        </member>
        <member name="M:HSS.IO.Zip.ZipFile.Read(System.IO.Stream)">
             <summary>
             Reads a zip archive from a stream.
             </summary>
            
             <remarks>
             <para>
             This is useful when when the zip archive content is available from 
             an already-open stream. The stream must be open and readable when calling this
             method.  The stream is left open when the reading is completed. 
             </para>
             <para>
             The stream is read using the default <c>System.Text.Encoding</c>, which is the <c>IBM437</c> codepage.  
             </para>
             </remarks>
            
             <example>
             This example shows how to Read zip content from a stream, and extract
             one entry into a different stream. In this example, the filename
             "NameOfEntryInArchive.doc", refers only to the name of the entry
             within the zip archive.  A file by that name is not created in the
             filesystem.  The I/O is done strictly with the given streams.
             <code>
             using (ZipFile zip = ZipFile.Read(InputStream))
             {
               zip.Extract("NameOfEntryInArchive.doc", OutputStream);
             }
             </code>
             <code lang="VB">
             Using zip as ZipFile = ZipFile.Read(InputStream)
               zip.Extract("NameOfEntryInArchive.doc", OutputStream)
             End Using
             </code>
             </example>
            
             <param name="zipStream">the stream containing the zip data.</param>
             <returns>an instance of ZipFile</returns>
        </member>
        <member name="M:HSS.IO.Zip.ZipFile.Read(System.IO.Stream,System.IO.TextWriter)">
             <summary>
             Reads a zip archive from a stream, using the specified TextWriter for status messages.
             </summary>
             
             <remarks>
             <para>
             This method is useful when when the zip archive content is available from 
             an already-open stream. The stream must be open and readable when calling this
             method.  The stream is left open when the reading is completed. 
             </para>
             
             <para>
             The stream is read using the default <c>System.Text.Encoding</c>, which is the <c>IBM437</c> codepage.  
             For more information on the encoding, see the <see cref="P:HSS.IO.Zip.ZipFile.Encoding">Encoding</see> property.
             </para>
             </remarks>
            
             <exception cref="T:HSS.IO.Zip.ZipException">
             Thrown if zipStream is null.
             In this case, the inner exception is an ArgumentException.
             </exception>
            
             <param name="zipStream">the stream containing the zip data.</param>
             
             <param name="statusMessageWriter">
             The <c>System.IO.TextWriter</c> to which verbose status messages are written during operations on the ZipFile.  
             For example, in a console application, System.Console.Out works, and will get a message for each entry added to the ZipFile. 
             If the TextWriter is null, no verbose messages are written. 
             </param>
             
             <returns>an instance of ZipFile</returns>
        </member>
        <member name="M:HSS.IO.Zip.ZipFile.Read(System.IO.Stream,System.Text.Encoding)">
             <summary>
             Reads a zip archive from a stream, using the specified encoding.
             </summary>
             
             <remarks>
             <para>
             This method is useful when when the zip archive content is available from 
             an already-open stream. The stream must be open and readable when calling this
             method.  The stream is left open when the reading is completed. 
             </para>
             </remarks>
            
             <exception cref="T:HSS.IO.Zip.ZipException">
             Thrown if zipStream is null.
             In this case, the inner exception is an ArgumentException.
             </exception>
            
             <param name="zipStream">the stream containing the zip data.</param>
             
             <param name="encoding">
             The text encoding to use when reading entries that do not have the UTF-8 encoding bit set. 
             See the <see cref="P:HSS.IO.Zip.ZipFile.Encoding">Encoding</see> property for more information. 
             </param>
             
             <returns>an instance of ZipFile</returns>
        </member>
        <member name="M:HSS.IO.Zip.ZipFile.Read(System.IO.Stream,System.IO.TextWriter,System.Text.Encoding)">
             <summary>
             Reads a zip archive from a stream, using the specified text Encoding and the specified TextWriter for status messages.
             </summary>
             <remarks>
             <para>
             This method is useful when when the zip archive content is available from 
             an already-open stream. The stream must be open and readable when calling this
             method.  The stream is left open when the reading is completed. 
             </para>
             </remarks>
            
             <exception cref="T:HSS.IO.Zip.ZipException">
             Thrown if zipStream is null.
             In this case, the inner exception is an ArgumentException.
             </exception>
            
             <param name="zipStream">the stream containing the zip data.</param>
             <param name="statusMessageWriter">
             The <c>System.IO.TextWriter</c> to which verbose status messages are written during operations on the ZipFile.  
             For example, in a console application, System.Console.Out works, and will get a message for each entry added to the ZipFile. 
             If the TextWriter is null, no verbose messages are written. 
             </param>
             <param name="encoding">
             The text encoding to use when reading entries that do not have the UTF-8 encoding bit set. 
             See the <see cref="P:HSS.IO.Zip.ZipFile.Encoding">Encoding</see> property for more information. 
             </param>
             <returns>an instance of ZipFile</returns>
        </member>
        <member name="M:HSS.IO.Zip.ZipFile.Read(System.Byte[])">
            <summary>
            Reads a zip archive from a byte array.
            </summary>
            
            <remarks>
            This is useful when the data for the zipfile is contained in a byte array, 
            for example, downloaded from an FTP server without being saved to a
            filesystem. 
            </remarks>
            
            <param name="buffer">
            The byte array containing the zip data.  
            (I don't know why, but sometimes the compiled helpfuile (.chm) indicates a 2d 
            array when it is just one-dimensional.  This is a one-dimensional array.)
            </param>
            
            <returns>an instance of ZipFile. The name on the ZipFile will be null (nothing in VB)). </returns>
        </member>
        <member name="M:HSS.IO.Zip.ZipFile.Read(System.Byte[],System.IO.TextWriter)">
            <summary>
            Reads a zip archive from a byte array, using the given StatusMessageWriter.
            </summary>
            
            <remarks>
            <para>
            This method is useful when the data for the zipfile is contained in a byte array, for
            example when retrieving the data from a database or other non-filesystem store.  
            The default Text Encoding (IBM437) is used to read the zipfile data.
            </para>
            
            </remarks>
            
            <param name="buffer">the byte array containing the zip data.</param>
            <param name="statusMessageWriter">
            The <c>System.IO.TextWriter</c> to which verbose status messages are written during operations on the ZipFile.  
            For example, in a console application, System.Console.Out works, and will get a message for each entry added to the ZipFile. 
            If the TextWriter is null, no verbose messages are written. 
            </param>
            
            <returns>an instance of ZipFile. The name is set to null.</returns>
            
        </member>
        <member name="M:HSS.IO.Zip.ZipFile.Read(System.Byte[],System.IO.TextWriter,System.Text.Encoding)">
            <summary>
            Reads a zip archive from a byte array, using the given StatusMessageWriter and text Encoding.
            </summary>
            
            <remarks>
            <para>
            This method is useful when the data for the zipfile is contained in a byte array, for
            example when retrieving the data from a database or other non-filesystem store.  
            </para>
            
            </remarks>
            
            <param name="buffer">the byte array containing the zip data.</param>
            <param name="statusMessageWriter">
            The <c>System.IO.TextWriter</c> to which verbose status messages are written during operations on the ZipFile.  
            For example, in a console application, System.Console.Out works, and will get a message for each entry added to the ZipFile. 
            If the TextWriter is null, no verbose messages are written. 
            </param>
            
            <param name="encoding">
            The text encoding to use when reading entries that do not have the UTF-8 encoding bit set. 
            See the <see cref="P:HSS.IO.Zip.ZipFile.Encoding">Encoding</see> property for more information. 
            </param>
                    
            <returns>an instance of ZipFile. The name is set to null.</returns>
            
        </member>
        <member name="M:HSS.IO.Zip.ZipFile.GetEnumerator">
             <summary>
             Generic IEnumerator support, for use of a ZipFile in a foreach construct.  
             </summary>
            
             <remarks>
             You probably do not want to call <c>GetEnumerator</c> explicitly. Instead 
             it is implicitly called when you use a <c>foreach</c> loop in C#, or a 
             <c>For Each</c> loop in VB.
             </remarks>
            
             <example>
             This example reads a zipfile of a given name, then enumerates the 
             entries in that zip file, and displays the information about each 
             entry on the Console.
             <code>
             using (ZipFile zip = ZipFile.Read(zipfile))
             {
               bool header = true;
               foreach (ZipEntry e in zip)
               {
                 if (header)
                 {
                    System.Console.WriteLine("Zipfile: {0}", zip.Name);
                    System.Console.WriteLine("Version Needed: 0x{0:X2}", e.VersionNeeded);
                    System.Console.WriteLine("BitField: 0x{0:X2}", e.BitField);
                    System.Console.WriteLine("Compression Method: 0x{0:X2}", e.CompressionMethod);
                    System.Console.WriteLine("\n{1,-22} {2,-6} {3,4}   {4,-8}  {0}",
                                 "Filename", "Modified", "Size", "Ratio", "Packed");
                    System.Console.WriteLine(new System.String('-', 72));
                    header = false;
                 }
            
                 System.Console.WriteLine("{1,-22} {2,-6} {3,4:F0}%   {4,-8}  {0}",
                             e.FileName,
                             e.LastModified.ToString("yyyy-MM-dd HH:mm:ss"),
                             e.UncompressedSize,
                             e.CompressionRatio,
                             e.CompressedSize);
            
                 e.Extract();
               }
             }
             </code>
            
             <code lang="VB">
               Dim ZipFileToExtract As String = "c:\foo.zip"
               Using zip As ZipFile = ZipFile.Read(ZipFileToExtract)
                   Dim header As Boolean = True
                   Dim e As ZipEntry
                   For Each e In zip
                       If header Then
                           Console.WriteLine("Zipfile: {0}", zip.Name)
                           Console.WriteLine("Version Needed: 0x{0:X2}", e.VersionNeeded)
                           Console.WriteLine("BitField: 0x{0:X2}", e.BitField)
                           Console.WriteLine("Compression Method: 0x{0:X2}", e.CompressionMethod)
                           Console.WriteLine(ChrW(10) &amp; "{1,-22} {2,-6} {3,4}   {4,-8}  {0}", _
                             "Filename", "Modified", "Size", "Ratio", "Packed" )
                           Console.WriteLine(New String("-"c, 72))
                           header = False
                       End If
                       Console.WriteLine("{1,-22} {2,-6} {3,4:F0}%   {4,-8}  {0}", _
                         e.FileName, _
                         e.LastModified.ToString("yyyy-MM-dd HH:mm:ss"), _
                         e.UncompressedSize, _
                         e.CompressionRatio, _
                         e.CompressedSize )
                       e.Extract
                   Next
               End Using
             </code>
             </example>
             
             <returns>A generic enumerator suitable for use  within a foreach loop.</returns>
        </member>
        <member name="M:HSS.IO.Zip.ZipFile.System#Collections#IEnumerable#GetEnumerator">
            <summary>
            IEnumerator support, for use of a ZipFile in a foreach construct.  
            </summary>
        </member>
        <member name="M:HSS.IO.Zip.ZipFile.ExtractAll(System.String)">
             <summary>
             Extracts all of the items in the zip archive, to the specified path in the filesystem.
             The path can be relative or fully-qualified. 
             </summary>
            
             <remarks>
             <para>
             If an extraction of a file from the zip archive would overwrite an existing file
             in the filesystem, the file will not be overwritten and an exception will be
             thrown. To avoid this, use the overload that allows you to specify that you want
             to overwrite existing files.
             </para>
            
             <para>
             This method will send verbose output messages to the StatusMessageTextWriter, if it 
             is set on the ZipFile instance. 
             </para>
            
             <para>
             You may also wish to take advantage of the <c>ExtractStarted</c>,
             <c>ExtractProgress</c>, and <c>ExtractCompleted</c> events.
             </para>
            
             </remarks>
            
             <seealso cref="M:HSS.IO.Zip.ZipFile.ExtractAll(System.String,System.Boolean)"/>
             <seealso cref="E:HSS.IO.Zip.ZipFile.ExtractStarted"/>
             <seealso cref="E:HSS.IO.Zip.ZipFile.ExtractProgress"/>
            
             <param name="path">The path to which the contents of the zip archive should be extracted.</param>
        </member>
        <member name="M:HSS.IO.Zip.ZipFile.ExtractAll(System.String,System.Boolean)">
             <summary>
             Extracts all of the items in the zip archive, to the specified path in the filesystem,  
             optionally overwriting any existing files. The path can be relative or fully-qualified. 
             </summary>
            
             <remarks>
             This method will send verbose output messages to the StatusMessageTextWriter, if it 
             is set on the ZipFile instance. 
             </remarks>
            
             <example>
             This example extracts all the entries in a zip archive file, 
             to the specified target directory.  It overwrites any existing files.
             It also handles exceptions that may be thrown, such as unauthorized 
             access exceptions.
             <code>
             String TargetDirectory= "c:\\temp\\unpack";
             try 
             {
               using(ZipFile zip= ZipFile.Read(ZipFileToExtract))
               {
                 zip.ExtractAll(TargetDirectory, true);
               }
             }
             catch (System.Exception ex1)
             {
               System.Console.Error.WriteLine("exception: {0}", ex1);
             }
             </code>
             
             <code lang="VB">
               Dim TargetDirectory As String = "c:\temp\unpack"
               Try 
                   Using zip As ZipFile = ZipFile.Read(ZipFileToExtract)
                       zip.ExtractAll(TargetDirectory, True)
                   End Using
               Catch ex1 As Exception
                   Console.Error.WriteLine("exception: {0}", ex1.ToString)
               End Try
             </code>
             </example>
             
             <param name="path">the path to which the contents of the zipfile are extracted.</param>
             <param name="wantOverwrite">true to overwrite any existing files on extraction</param>
        </member>
        <member name="M:HSS.IO.Zip.ZipFile.Extract(System.String)">
            <summary>
            Extract a single item from the archive.  The file, including any relative
            qualifying path, is created at the current working directory.  
            </summary>
            
            <remarks>
            Calling this method, the entry is extracted using the Password that is 
            specified on the ZipFile instance. If you have not set the Password property, then
            the password is null, and the entry is extracted with no password.
            </remarks>
            
            <param name="fileName">
            The file to extract. It must be the exact filename, including the path
            contained in the archive, if any. The filename match is not case-sensitive by
            default; you can use the <c>CaseSensitiveRetrieval</c> property to change
            this behavior.
            </param>
        </member>
        <member name="M:HSS.IO.Zip.ZipFile.Extract(System.String,System.String)">
             <summary>
             Extract a single item from the archive.  The file, including any relative
             qualifying path, is created at the current working directory.  
             </summary>
            
             <remarks>
             Calling this method, the entry is extracted using the Password that is 
             specified on the ZipFile instance. If you have not set the Password property, then
             the password is null, and the entry is extracted with no password.
             </remarks>
             
             <param name="fileName">
             the file to extract. It must be the exact filename, including the path
             contained in the archive, if any. The filename match is not case-sensitive by
             default; you can use the <c>CaseSensitiveRetrieval</c> property to change
             this behavior.
             </param>
             <param name="directoryName">the directory into which to extract. It should exist.</param>
        </member>
        <member name="M:HSS.IO.Zip.ZipFile.Extract(System.String,System.Boolean)">
             <summary>
             Extract a single item from the archive, potentially overwriting  
             any existing file in the filesystem by the same name. The file, including any relative 
             qualifying path, is created at the current working directory.  
             </summary>
             
             <remarks>
             Calling this method, the entry is extracted using the Password that is 
             specified on the ZipFile instance. If you have not set the Password property, then
             the password is null, and the entry is extracted with no password.
             </remarks>
             
             <param name="fileName">
             The file to extract. It must be the exact filename, including the path contained in the 
             archive, if any. The filename match is not case-sensitive by default; you can use the <c>CaseSensitiveRetrieval</c> 
             property to change this behavior.
             The pathname can use forward-slashes or backward slashes.
             </param>
            
             <seealso cref="P:HSS.IO.Zip.ZipFile.CaseSensitiveRetrieval"/>
            
             <param name="wantOverwrite">True if the caller wants to overwrite any existing files by the given name.</param>
        </member>
        <member name="M:HSS.IO.Zip.ZipFile.Extract(System.String,System.String,System.Boolean)">
            <summary>
            Extract a single item from the archive, into the specified directory, potentially overwriting  
            any existing file in the filesystem by the same name. The file, including any relative 
            qualifying path, is created in the specified directory.  
            </summary>
            
            <remarks>
            Calling this method, the entry is extracted using the Password that is 
            specified on the ZipFile instance. If you have not set the Password property, then
            the password is null, and the entry is extracted with no password.
            </remarks>
            
            <param name="fileName">
            The file to extract. It must be the exact filename, including the path contained in the archive, 
            if any. The filename match is not case-sensitive by default; you can use the <c>CaseSensitiveRetrieval</c> 
            property to change this behavior. The pathname can use forward-slashes or backward slashes.
            </param>
            <param name="directoryName">the directory into which to extract. It should exist.</param>
            <param name="wantOverwrite">True if the caller wants to overwrite any existing files by the given name.</param>
        </member>
        <member name="M:HSS.IO.Zip.ZipFile.Extract(System.String,System.IO.Stream)">
             <summary>
             Extract a single specified file from the archive, to the given stream.  This is 
             useful when extracting to Console.Out or to a memory stream, for example. 
             </summary>
             
             <remarks>
             Calling this method, the entry is extracted using the Password that is 
             specified on the ZipFile instance. If you have not set the Password property, then
             the password is null, and the entry is extracted with no password.
             </remarks>
             
             <exception cref="T:HSS.IO.Zip.ZipException">
             Thrown if the outputStream is not writable, or if the filename is 
             null or empty. The inner exception is an ArgumentException in each case.
             </exception>
            
             <param name="fileName">
             the file to extract. It should include pathnames used in the archive, if any.
             The filename match is not case-sensitive by default; you can use the
             <c>CaseSensitiveRetrieval</c> property to change this behavior.The
             application can specify pathnames using forward-slashes or backward slashes.
             </param>
            
             <param name="outputStream">
             the stream to which the extacted, decompressed file data is written. 
             The stream must be writable.
             </param>
        </member>
        <member name="M:HSS.IO.Zip.ZipFile.RemoveEntry(HSS.IO.Zip.ZipEntry)">
             <summary>
             Removes the given ZipEntry from the zip archive.  
             </summary>
             
             <remarks>
             <para>
             After calling <c>RemoveEntry</c>, the application must call <c>Save</c> to make the 
             changes permanent.  
             </para>
             </remarks>
            
             <exception cref="T:System.ArgumentException">
             Thrown if the specified ZipEntry does not exist in the ZipFile.
             </exception>
            
             <example>
             In this example, all entries in the zip archive dating from before December 31st, 2007, are
             removed from the archive.
             <code>
             System.DateTime Threshold = new System.DateTime(2007,12,31);
             using (ZipFile zip = new ZipFile(ZipFileToRead))
             {
               var EntriesToRemove = new System.Collections.Generic.List&lt;ZipEntry&gt;();
               foreach (ZipEntry e in zip)
               {
                 if (e.LastModified &lt; Threshold)
                 {
                   // We cannot remove the entry from the list, within the context of 
                   // an enumeration of said list.
                   // So we add the doomed entry to a list to be removed later.
                   EntriesToRemove.Add(e);
                 }
               }
               
               // actually remove the doomed entries. 
               foreach (ZipEntry zombie in EntriesToRemove)
                 zip.RemoveEntry(zombie);
               
               zip.Comment= String.Format("This zip archive was updated at {0}.", 
                                          System.DateTime.Now.ToString("G"));
               zip.Save();
             }
             </code>
             
             <code lang="VB">
               Dim ZipFileToRead As String = "c:\foo.zip"
               Dim Threshold As New DateTime(2007, 12, 31)
               Using zip As ZipFile = New ZipFile(ZipFileToRead)
                   Dim EntriesToRemove As New System.Collections.Generic.List(Of ZipEntry)
                   Dim e As ZipEntry
                   For Each e In zip
                       If (e.LastModified &lt; Threshold) Then
                           ' We cannot remove the entry from the list, within the context of 
                           ' an enumeration of said list.
                           ' So we add the doomed entry to a list to be removed later.
                           EntriesToRemove.Add(e)
                       End If
                   Next
               
                   ' actually remove the doomed entries. 
                   Dim zombie As ZipEntry
                   For Each zombie In EntriesToRemove
                       zip.RemoveEntry(zombie)
                   Next
                   zip.Comment = String.Format("This zip archive was updated at {0}.", DateTime.Now.ToString("G"))
                   zip.Save
               End Using
             </code>
             </example>
             
             <param name="entry">
             The ZipEntry to remove from the zip. 
             </param>
             
        </member>
        <member name="M:HSS.IO.Zip.ZipFile.RemoveEntry(System.String)">
             <summary>
             Removes the ZipEntry with the given filename from the zip archive.  
             </summary>
             
             <remarks>
             <para>
             After calling <c>RemoveEntry</c>, the application must call <c>Save</c> to make the changes permanent.  
             </para>
            
             </remarks>
            
             <exception cref="T:System.InvalidOperationException">
             Thrown if the ZipFile is not updatable. 
             </exception>
            
             <exception cref="T:System.ArgumentException">
             Thrown if a ZipEntry with the specified filename does not exist in the ZipFile.
             </exception>
            
             <example>
             This example shows one way to remove an entry with a given filename from an 
             existing zip archive.
             <code>
             String ZipFileToRead= "PackedDocuments.zip";
             string Candidate = "DatedMaterial.xps";
             using (ZipFile zip = new ZipFile(ZipFileToRead))
             {
               if (zip.EntryFilenames.Contains(Candidate))
               {
                 zip.RemoveEntry(Candidate);
                 zip.Comment= String.Format("The file '{0}' has been removed from this archive.", 
                                            Candidate);
                 zip.Save();
               }
             }
             </code>
             <code lang="VB">
               Dim ZipFileToRead As String = "PackedDocuments.zip"
               Dim Candidate As String = "DatedMaterial.xps"
               Using zip As ZipFile = New ZipFile(ZipFileToRead)
                   If zip.EntryFilenames.Contains(Candidate) Then
                       zip.RemoveEntry(Candidate)
                       zip.Comment = String.Format("The file '{0}' has been removed from this archive.", Candidate)
                       zip.Save
                   End If
               End Using
             </code>
             </example>
             
             <param name="fileName">
             The name of the file, including any directory path, to remove from the zip. 
             The filename match is not case-sensitive by default; you can use the
             <c>CaseSensitiveRetrieval</c> property to change this behavior. The
             pathname can use forward-slashes or backward slashes.
             </param>
             
        </member>
        <member name="P:HSS.IO.Zip.ZipFile.Name">
            <summary>
            This read-only property specifies the name of the zipfile to read or write. It is 
            set when the instance of the ZipFile type is created. When instantiating a ZipFile 
            to read from or write to a stream, the Name property remains null.
            </summary>
        </member>
        <member name="P:HSS.IO.Zip.ZipFile.Comment">
             <summary>
             A comment attached to the zip archive.
             </summary>
            
             <remarks>
             <para>
             This property is read/write for the zipfile. It allows the application to
             specify a comment for the zipfile, or read the comment for the zipfile. 
             If setting the comment, changes are only made permanent when you call a
             <c>Save()</c> method.
             </para>
             <para>
             According to the zip spec, the comment is not encrypted, even if there is a password
             set on the zip archive. 
             </para>
             </remarks>
        </member>
        <member name="P:HSS.IO.Zip.ZipFile.TrimVolumeFromFullyQualifiedPaths">
             <summary>
             When this is set, any volume name (eg C:) is trimmed 
             from fully-qualified pathnames on any ZipEntry, before writing the 
             ZipEntry into the ZipFile. 
             </summary>
            
             <remarks>
             <para>
             The default value is true. This setting must be true to allow 
             Windows Explorer to read the zip archives properly. It's also required to be 
             true if you want to read the generated zip files on any other non-Windows OS. 
             </para>
             
             <para>
             The property is included for backwards compatibility only.  You'll 
             almost never need or want to set this to false.
             </para>
             </remarks>
            
        </member>
        <member name="P:HSS.IO.Zip.ZipFile.CaseSensitiveRetrieval">
            <summary>
            Indicates whether to perform case-sensitive matching on the
            filename when retrieving entries in the zipfile via the string-based indexer. 
            The default value is false, which means DON'T do case-sensitive matching.
            It really makes sense to set this to TRUE only if you are not running on
            Windows, which has case-insensitive filenames.  In most cases you should just 
            leave this property alone. 
            </summary>
        </member>
        <member name="P:HSS.IO.Zip.ZipFile.UseUnicode">
            <summary>
            Indicates whether to encode entry filenames and entry comments using Unicode 
            (UTF-8) according to the PKWare specification, for those filenames and comments
            that cannot be encoded in the ASCII character set.
            </summary>
            <remarks>
            <para>
            The PKWare specification provides for encoding in either the IBM437 code page, or in UTF-8. 
            This flag selects the encoding according to that specification. 
            By default, this flag is false, and filenames and comments are encoded 
            into the zip file in the IBM437 codepage. 
            Setting this flag to true will specify that
            filenames and comments are encoded with UTF-8. 
            </para>
            <para>
            Zip files created with strict adherence to the PKWare specification
            with respect to UTF-8 encoding can contain entries with filenames containing
            any combination of Unicode characters, including the full 
            range of characters from Chinese, Latin, Hebrew, Greek, Cyrillic, and many 
            other alphabets. 
            However, because the UTF-8 portion of the PKWare specification is not broadly
            supported by other zip libraries and utilities, such zip files may not
            be readable by your favorite zip tool or archiver. In other words, interoperability
            will suffer if you set this flag to true. 
            </para>
            <para>
            In particular, Zip files created with strict adherence to the PKWare 
            specification with respect to UTF-8 encoding will not work well with 
            Explorer in Windows XP or Windows Vista, because Vista compressed folders 
            do not support UTF-8 in zip files.  Vista can read the zip files, but shows
            the filenames incorrectly.  Unpacking from Windows Vista Explorer will result in filenames
            that have rubbish characters in place of the high-order UTF-8 bytes.
            </para>
            <para>
            Also, zip files that use UTF-8 encoding will not work well 
            with Java applications that use the java.util.zip classes, as of 
            v5.0 of the Java runtime. The Java runtime does not correctly 
            implement the PKWare specification in this regard.
            </para>
            <para>
            As a result, we have the curious situation that "correct" 
            behavior during zip creation will result in zip files that 
            are not able to be read by various other tools.
            </para>
            <para>
            The library can read and write zip files 
            with UTF8-encoded entries, according to the PKware spec.  If you use this library for both 
            creating and reading the zip file, and you use UTF-8, there will be no loss of information 
            in the filenames. For example, using a self-extractor created by this
            library will allow you to unpack files correctly with no loss of 
            information in the filenames. 
            </para>
            <para>
            Encoding filenames and comments using the IBM437 codepage, the default
            behavior, will cause loss of information on some filenames that contain 
            super-ASCII characters, but the resulting zipfile will
            be more interoperable with other utilities. As an example of the 
            loss of information, the o-tilde character will be down-coded to plain o. 
            Likewise, the O with a stroke through it, used in Danish and Norwegian,
            will be down-coded to plain o. Chinese characters cannot be represented
            in codepage IBM437; when using the default encoding, Chinese characters in 
            filenames will be represented as ?.  
            </para>
            <para>
            The loss of information associated to the use of the IBM437 encoding can 
            lead to runtime errors. For example, using 
            IBM437, any sequence of 4 Chinese characters will be encoded as 
            ????.  If your application creates a ZipFile, then adds two files, each with 
            names of four Chinese characters each, this will result in a duplicate 
            filename exception.  In the case where you add a single file with a name 
            containing four Chinese characters, attempting to unzip the file to the Windows
            filesystem will lead to an exception, because ? is not a legal character in a filename.         
            These are just a few examples of the problems associated to loss of information.
            </para>
            <para>
            This flag has no effect or relation to the encoding of the content within the 
            entries in the zip file.  
            </para>
            <para>
            Rather than specify the encoding in a binary fashion using this flag, an application
            can specify an arbitrary encoding via the <c>Encoding</c>property.  Setting 
            the encoding explicitly when creating zip archives will result in non-compliant 
            zip files that, curiously, are fairly interoperable.  The challenge is, the PKWare specification
            does not provide for a way to specify an arbitrary code page for an entry.  Therefore 
            if you set the encoding explicitly when creating a zip archive, you must take care upon 
            reading the zip archive to use the same code page.  If you get it wrong, the behavior is 
            undefined and may result in incorrect filenames, exceptions, and acne.  
            </para>
            <seealso cref="P:HSS.IO.Zip.ZipFile.Encoding">Encoding</seealso>
            </remarks>
        </member>
        <member name="P:HSS.IO.Zip.ZipFile.Encoding">
            <summary>
            The text encoding to use when writing new entries to the ZipFile.  
            </summary>
            
            <remarks>
            <para>
            In its AppNote.txt document, PKWare describes how to specify in the zip entry header
            that a filename or comment containing non-ANSI characters is encoded with UTF-8.  But, some 
            archivers do not follow the specification, and instead encode super-ANSI characters using the 
            system default code page.  For example, WinRAR when run on a machine in Shanghai may encode 
            filenames with the Chinese code page.  This behavior is contrary to the Zip specification, but it 
            occurs anyway.
            </para>
            <para>
            When writing zip archives that will be read by one of these other archivers, 
            set this property to specify the code page to use when encoding filenames and comments into the zip file.
            </para>
            <para>
            The default encoding is codepage IBM437.  Be aware that a zip file created after you've explicitly 
            specified the code page will not be compliant to the PKWare specification, and may not be readable 
            by compliant archivers.  On the other hand, many (most?) archivers are non-compliant and can read zip files 
            created in arbitrary code pages.  The trick is to use the proper codepage when reading the zip.
            </para>
            <para>
            When using an arbitrary, non-UTF8 code page for encoding, there is no standard way for the 
            creator application - whether this library, WinRar, or something else - to specify in the zip file 
            which codepage has been used. As a result, readers of zip files are not
            able to inspect the zip file and determine the codepage that was used for the entries contained within it. 
            It is left to the application to determine the necessary codepage when reading zipfiles encoded this way.  
            If you use an incorrect codepage when reading a zipfile, you can get entries with filenames
            that are either incorrect or not legal in Windows. Extracting entries with illegal characters 
            in the filenames will lead to exceptions. Caveat Emptor.
            </para>
            </remarks>
            
            <seealso cref="F:HSS.IO.Zip.ZipFile.DefaultEncoding">DefaultEncoding</seealso>.
        </member>
        <member name="P:HSS.IO.Zip.ZipFile.StatusMessageTextWriter">
             <summary>
             Gets or sets the <c>TextWriter</c> to which status messages are delivered 
             for the instance. If the TextWriter is set to a non-null value, then 
             verbose output is sent to the <c>TextWriter</c> during <c>Add</c><c>, Read</c><c>, Save</c> and
             <c>Extract</c> operations.  
             </summary>
            
             <example>
             <para>
             In this example, a console application instantiates a ZipFile, then sets
             the StatusMessageTextWriter to Console.Out.  At that point, all verbose
             status messages for that ZipFile are sent to the console. 
             </para>
            
             <code lang="C#">
             using (ZipFile zip= new ZipFile(FilePath))
             {
               zip.StatusMessageTextWriter= System.Console.Out;
               // messages are sent to the console during extraction
               zip.ExtractAll();
             }
             </code>
            
             <code lang="VB">
             Using zip As new ZipFile(FilePath)
               zip.StatusMessageTextWriter= System.Console.Out
               'Status Messages will be sent to the console during extraction
               zip.ExtractAll()
             End Using
             </code>
             </example>
        </member>
        <member name="P:HSS.IO.Zip.ZipFile.ForceNoCompression">
             <summary>
             Gets or sets the flag that indicates whether the ZipFile should use
             compression for subsequently added entries in the ZipFile instance.
             </summary>
            
             <remarks>
             <para> 
             When saving an entry into a zip archive, we first compress
             the file, then compares the size of the pre-compressed data with the size of the
             post-compressed data. For files that are already compressed, like MP3's or JPGs,
             the deflate algorithm can actually expand the size of the data.  In this case,
             the library uses the pre-compressed data and simply stores the file
             data into the archive. 
             </para> 
            
             <para>
             The library does this optimization automatically.  To avoid the
             unnecessary processing and comparison, the application can explicitly request
             that Compression not be used, by setting this flag.  The default value is false.
             </para> 
            
             <para>
             Do not construe setting this flag to false as "Force Compression".  Setting it
             to false merely does NOT force No compression.  Think about it a little bit:
             There's a difference.  If you want to force the use fo deflate algorithm when
             storing each entry into the zip archive, define a <see cref="P:HSS.IO.Zip.ZipFile.WillReadTwiceOnInflation"/> callback, which always returns false.  This is
             probably the wrong thing to do, but you could do it.  Forcing the use of the
             Deflate algorithm when storing an entry does not guarantee that the data size
             will get smaller. It could increase, as described above.  But if you want to be
             pig-headed about it, go ahead.
             </para>
            
             <para>
             Changes to this flag apply to all entries subsequently added to the archive. 
             The application can also set the CompressionMethod
             property on each ZipEntry, for more granular control of this capability.
             </para>
            
             </remarks>
            
             <seealso cref="P:HSS.IO.Zip.ZipEntry.CompressionMethod"/>
            
             <example>
             This example shows how to specify that Compression will not be used when adding files 
             to the zip archive. None of the files added to the archive in this way will use
             compression.
             <code>
             using (ZipFile zip = new ZipFile(ZipFileToCreate))
             {
               zip.ForceNoCompression = true;
               zip.AddDirectory(@"c:\temp\Foo");
               zip.Comment = "All files in this archive will be uncompressed.";
               zip.Save();
             }
             </code>
            
             <code lang="VB">
             Using zip As New ZipFile(ZipFileToCreate)
               zip.ForceNoCompression = true
               zip.AddDirectory("c:\temp\Foo")
               zip.Comment = "All files in this archive will be uncompressed."
               zip.Save()
             End Using
             </code>
            
             </example>
        </member>
        <member name="P:HSS.IO.Zip.ZipFile.TempFileFolder">
             <summary>
             Gets or sets the name for the folder to store the temporary file
             this library writes when saving the zip archive. 
             </summary>
            
             <remarks>
             The calling application should have write and delete rights on that folder.  By
             default, the temp file folder is the directory referred to by the TEMP
             environment variable.  If that variable is not set, this value defaults to the
             current working directory.  But for some scenarios, such as ASP.NET
             applications, the application may wish to explicitly override this,
             with this public property. This property is used only when calling one of the
             <c>Save()</c> methods, or the <c>SaveSelfExtractor()</c> method.
             </remarks>
            
             <exception cref="T:System.IO.FileNotFoundException">
             Thrown upon setting the property if the directory does not exist. 
             </exception>
            
        </member>
        <member name="P:HSS.IO.Zip.ZipFile.Password">
             <summary>
             Sets the password to be used for any entry subsequently added 
             to the ZipFile, using one of the AddFile, AddDirectory, or AddItem methods; 
             or any entry subsequently extracted from the ZipFile using one of the Extract methods on the ZipFile class.  
             This password is applied to the entries, not
             to the zip archive itself. 
             </summary>
             <remarks>
             
             <para>
             Though the password is set on the ZipFile object, the password
             actually does not apply to the archive as a whole.  Instead, it
             applies to individual entries that are added to the archive, from
             that point in time onward.  The "directory" of the archive - in other
             words the list of files - is not encrypted with the password, The
             list of filenames in the archive is in clear text.  but the contents
             of the individual files are encrypted.
             </para>
             
             <para>
             If you set the password on the zip archive, and then add a set of files to the 
             archive, then each entry is encrypted with that password.  You may also want 
             to change the password between adding different entries. If you set the 
             password, add an entry, then set the password to null, and add another entry,
             the first entry is encrypted and the second is not.  Furshtay?
             </para>
             
             <para>
             If you read in an existing ZipFile, then set the Password property, then call
             one of the ZipFile.Extract() overloads, the entry is extracted using the Password that is 
             specified on the ZipFile instance. If you have not set the Password property, then
             the password is null, and the entry is extracted with no password.
             </para>
             
             </remarks>
            
             <example>
             <para>
             In this example, three files are added to a Zip archive. The ReadMe.txt file
             will be placed in the root of the archive, and will not be encrypted. 
             The .png file will be included into the zip, encrypted with the "123456!" password.
             The pdf file will be included, encrypted with "!Secret1" as the password.
             </para>
             <code>
                try
                {
                  using (ZipFile zip = new ZipFile("test3.zip",System.Console.Out))
                  {
                    zip.AddFile("ReadMe.txt");
                    zip.Password= "123456!";
                    zip.AddFile("7440-N49th.png");
                    zip.Password= "!Secret1";
                    zip.AddFile("2005_Annual_Report.pdf");
            
                    zip.Save();
                  }
                }
                catch (System.Exception ex1)
                {
                  System.Console.Error.WriteLine("exception: {0}", ex1);
                }
             </code>
            
             <code lang="VB">
              Try 
                Using zip As New ZipFile("test2.zip", System.Console.Out)
                  zip.AddFile("c:\datafiles\ReadMe.txt", "")
                  zip.Password = "123456!"
                  zip.AddFile("c:\photos\personal\7440-N49th.png", "images")
                  zip.Password= "!Secret1";
                  zip.AddFile("c:\Desktop\2005_Annual_Report.pdf", "files\documents")
                  zip.Save
                End Using
              Catch ex1 As System.Exception
                System.Console.Error.WriteLine("exception: {0}", ex1)
              End Try
             </code>
            
             </example>
             
        </member>
        <member name="P:HSS.IO.Zip.ZipFile.WillReadTwiceOnInflation">
             <summary>
             A callback that allows the application to specify whether multiple reads of the
             stream should be performed, in the case that a compression operation actually
             inflates the size of the file data.  
             </summary>
            
             <remarks>
             <para>
             In some cases, applying the Deflate compression algorithm in DeflateStream can
             result an increase in the size of the data.  This "inflation" can happen with
             previously compressed files, such as a zip, jpg, png, mp3, and so on.  In a few
             tests, inflation on zip files can be as large as 60%!  Inflation can also happen
             with very small files.  In these cases, by default, the library
             discards the compressed bytes, and stores the uncompressed file data into the
             zip archive.  This is an optimization where smaller size is preferred over
             longer run times.
             </para>
            
             <para>
             The application can specify that compression is not even tried, by setting the
             ForceNoCompression flag.  In this case, the compress-and-check-sizes process as
             decribed above, is not done.
             </para>
            
             <para>
             In some cases, neither choice is optimal.  The application wants compression,
             but in some cases also wants to avoid reading the stream more than once.  This
             may happen when the stream is very large, or when the read is very expensive, or
             when the difference between the compressed and uncompressed sizes is not
             significant.
             </para>
            
             <para>
             To satisfy these applications, this delegate allows the library to ask
             the application for approval for re-reading the stream, in the case where
             inflation occurs.  The callback is invoked only in the case of inflation; that
             is to say when the uncompressed stream is smaller than the compressed stream.
             </para>
            
             <para>
             As with other properties (like Password and ForceNoCompression), setting the
             corresponding delegate on the ZipFile class itself will set it on all ZipEntry
             items that are subsequently added to the ZipFile instance.
             </para>
            
             </remarks>
             <example>
             <para>
             In this example, the application callback checks to see if the difference
             between the compressed and uncompressed data is greater than 25%.  If it is,
             then the callback returns true, and the application tells the library to re-read
             the stream.  If not, then the callback returns false, and the library just keeps
             the "inflated" file data.
             </para>
            
             <code>
            
             public bool ReadTwiceCallback(int uncompressed, int compressed, string filename)
             {
                 return ((uncompressed * 1.0/compressed) &gt; 1.25);
             }
             
             public void CreateTheZip()
             {
                 using (ZipFile zip = new ZipFile())
                 {
                     zip2.WillReadTwiceOnInflation = ReadTwiceCallback;
                     zip2.AddFile(filename1);
                     zip2.AddFile(filename2);
                     zip2.Save(ZipFileToCreate);
                 }
             }
             </code>
             </example>
             <seealso cref="T:HSS.IO.Zip.RereadApprovalCallback"/>
             <seealso cref="P:HSS.IO.Zip.ZipEntry.WillReadTwiceOnInflation"/>
        </member>
        <member name="E:HSS.IO.Zip.ZipFile.SaveStarted">
            <summary>
            Fired when the save starts.
            </summary>
        </member>
        <member name="E:HSS.IO.Zip.ZipFile.SaveProgress">
             <summary>
             Fired after each entry has been written to the archive.
             </summary>
             <example>
             <code lang="C#">
             public static void SaveProgress(object sender, SaveProgressEventArgs e)
             {
               Console.WriteLine("{0} ({1}/{2})", e.NameOfLatestEntry, e.EntriesSaved, e.EntriesTotal);
             }
             
             public static ZipUp(string targetZip, string directory)
             {
               using (var zip = new ZipFile()) {
                 zip.SaveProgress += SaveProgress; 
                 zip.AddDirectory(directory);
                 zip.Save(targetZip);
               }
             }
            
             </code>
             <code lang="VB">
             Public Sub ZipUp(ByVal targetZip As String, ByVal directory As String)
             	Try 
             	    Using zip As ZipFile = New ZipFile
             		AddHandler zip.SaveProgress, AddressOf MySaveProgress
             		zip.AddDirectory(directory)
             		zip.Save(targetZip)
             	    End Using
             	Catch ex1 As Exception
             	    Console.Error.WriteLine(("exception: " &amp; ex1.ToString))
             	End Try
             End Sub
             
             Public Sub MySaveProgress(ByVal sender As Object, ByVal e As SaveProgressEventArgs)
                 Console.WriteLine("{0} ({1}/{2})", e.NameOfLatestEntry, e.EntriesSaved, e.EntriesTotal)
             End Sub
             </code>
             </example>
        </member>
        <member name="E:HSS.IO.Zip.ZipFile.SaveCompleted">
            <summary>
            Fired after the save completes.
            </summary>
        </member>
        <member name="E:HSS.IO.Zip.ZipFile.ExtractStarted">
            <summary>
            Fired when the ExtractAll starts, before the first entry is extracted.
            </summary>
        </member>
        <member name="E:HSS.IO.Zip.ZipFile.ExtractProgress">
             <summary>
             Fired after each entry has been extracted from the archive, during the 
             execution of the ExtractAll method.
             </summary>
             <example>
             <code>
             public static void ExtractProgress(object sender, ExtractProgressEventArgs e)
             {
               Console.WriteLine("{0} ({1}/{2})", e.NameOfLatestEntry, e.EntriesExtractd, e.EntriesTotal);
             }
             
             public static ExtractZip(string zipToExtract, string directory)
             {
               using (var zip = new ZipFile(zipToExtract)) {
                 zip.ExtractProgress += ExtractProgress; 
                 zip.ExtractAll(directory, true);
               }
             }
            
             </code>
             </example>
        </member>
        <member name="E:HSS.IO.Zip.ZipFile.ExtractCompleted">
            <summary>
            Fired after the extract completes.
            </summary>
        </member>
        <member name="P:HSS.IO.Zip.ZipFile.Item(System.Int32)">
             <summary>
             This is an integer indexer into the Zip archive.  
             </summary>
             
             <remarks>
             <para>
             This property is read-write. But don't get too excited: When setting the value, the
             only legal value is null. If you assign a non-null value
             (non Nothing in VB), the setter will throw an exception.
             </para>
             <para>
             Setting the value to null is equivalent to calling <c>ZipFile.RemoveEntry</c> 
             with the filename for the given entry.
             </para>
             </remarks>
             
             <exception cref="T:System.ArgumentException">
             Thrown if the caller attempts to assign a non-null value to the indexer, 
             or if the caller uses an out-of-range index value.
             </exception>
            
             <param name="ix">
             The index value.
             </param>
             
             <returns>
             The ZipEntry within the Zip archive at the specified index. If the 
             entry does not exist in the archive, this indexer throws.
             </returns>
             
        </member>
        <member name="P:HSS.IO.Zip.ZipFile.Item(System.String)">
             <summary>
             This is a name-based indexer into the Zip archive.  
             </summary>
             
             <remarks>
             <para>
             Retrieval by the string-based indexer is done on a case-insensitive basis, 
             by default.  Set the <see cref="P:HSS.IO.Zip.ZipFile.CaseSensitiveRetrieval"/> property to use case-sensitive 
             comparisons. 
             </para>
             <para>
             This property is read-write. When setting the value, the
             only legal value is null. If you assign a non-null value
             (non Nothing in VB), the setter will throw an exception.
             </para>
             <para>
             Setting the value to null is equivalent to calling <c>ZipFile.RemoveEntry</c> 
             with the filename.
             </para>
             </remarks>
             
             <example>
             This example extracts only the entries in a zip file that are .txt files.
             <code>
             using (ZipFile zip = ZipFile.Read("PackedDocuments.zip"))
             {
               foreach (string s1 in zip.EntryFilenames)
               {
                 if (s1.EndsWith(".txt"))
                   zip[s1].Extract("textfiles");
               }
             }
             </code>
             <code lang="VB">
               Using zip As ZipFile = ZipFile.Read("PackedDocuments.zip")
                   Dim s1 As String
                   For Each s1 In zip.EntryFilenames
                       If s1.EndsWith(".txt") Then
                           zip(s1).Extract("textfiles")
                       End If
                   Next
               End Using
             </code>
             </example>
             <seealso cref="M:HSS.IO.Zip.ZipFile.RemoveEntry(System.String)"/>
            
             <exception cref="T:System.ArgumentException">
             Thrown if the caller attempts to assign a non-null value to the indexer.
             </exception>
            
             <param name="fileName">
             The name of the file, including any directory path, to retrieve from the zip. 
             The filename match is not case-sensitive by default; you can use the
             <c>CaseSensitiveRetrieval</c> property to change this behavior. The
             pathname can use forward-slashes or backward slashes.
             </param>
             
             <returns>
             The ZipEntry within the Zip archive, given by the specified filename. If the named
             entry does not exist in the archive, this indexer returns null.
             </returns>
             
        </member>
        <member name="P:HSS.IO.Zip.ZipFile.EntryFileNames">
             <summary>
             The list of filenames for the entries contained within the zip archive.  The 
             filenames use forward slashes in pathnames. 
             </summary>
            
             <seealso cref="P:HSS.IO.Zip.ZipFile.Item(System.String)"/>
            
             <example>
             This example shows one way to test if a filename is already contained within 
             a zip archive.
             <code>
             String ZipFileToRead= "PackedDocuments.zip";
             string Candidate = "DatedMaterial.xps";
             using (ZipFile zip = new ZipFile(ZipFileToRead))
             {
               if (zip.EntryFilenames.Contains(Candidate))
                 Console.WriteLine("The file '{0}' exists in the zip archive '{1}'",
                                   Candidate,
                                   ZipFileName);
               else
                 Console.WriteLine("The file, '{0}', does not exist in the zip archive '{1}'",
                                   Candidate,
                                   ZipFileName);
               Console.WriteLine();
             }
             </code>
             <code lang="VB">
               Dim ZipFileToRead As String = "PackedDocuments.zip"
               Dim Candidate As String = "DatedMaterial.xps"
               Using zip As New ZipFile(ZipFileToRead)
                   If zip.EntryFilenames.Contains(Candidate) Then
                       Console.WriteLine("The file '{0}' exists in the zip archive '{1}'", _
                                   Candidate, _
                                   ZipFileName)
                   Else
                     Console.WriteLine("The file, '{0}', does not exist in the zip archive '{1}'", _
                                   Candidate, _
                                   ZipFileName)
                   End If
                   Console.WriteLine
               End Using
             </code>
             </example>
            
             <returns>
             The list of strings for the filenames contained within the Zip archive.
             </returns>
             
        </member>
        <member name="T:HSS.IO.Zip.ZipFile.AddOrUpdateAction">
            <summary>
            Add or Update Action
            </summary>
        </member>
        <member name="T:HSS.IO.FileUtil">
            <summary>
            FileUtil Class contains helper methods when working with files and directories
            </summary>
        </member>
        <member name="F:HSS.IO.FileUtil.MaxPathLength">
            <summary>
            This is an arbitrary limitation built into the .NET Framework. Windows supports paths up to 32k length.
            </summary>
        </member>
        <member name="M:HSS.IO.FileUtil.Combine(System.String[])">
            <summary>
            Combine multiple paths
            </summary>
            <param name="paths">The string array of paths</param>
            <returns>The single combined path</returns>
        </member>
        <member name="M:HSS.IO.FileUtil.GetSafePath(System.String)">
            <summary>
            Removes unsafe Path characters from a string
            </summary>
            <param name="unsafePathName">The string to clean</param>
            <returns>The cleaned string</returns>
        </member>
        <member name="M:HSS.IO.FileUtil.GetSafeFileName(System.String)">
            <summary>
            Removes unsafe File Name characters from a string
            </summary>
            <param name="unsafeFileName">The string to clean</param>
            <returns>The cleaned string</returns>
        </member>
        <member name="M:HSS.IO.FileUtil.GetCommonBasePath(System.String,System.String)">
            <summary>
            Attempts to locate the common portion of the two paths
            </summary>
            <param name="path1">The first path to compare</param>
            <param name="path2">The second path to compare</param>
            <returns>The common portion of the two paths</returns>
        </member>
        <member name="M:HSS.IO.FileUtil.GetRelativePath(System.String,System.String)">
            <summary>
            Converts a given absolute path and a given base path to a path that leads
            from the base path to the absoulte path. (as a relative path)
            </summary>
            <param name="basePath">The base path to service as the relative source</param>
            <param name="absPath">The absolute path to convert</param>
            <returns>The relative path to the absolute path</returns>
        </member>
        <member name="M:HSS.IO.FileUtil.GetAbsolutePath(System.String,System.String)">
            <summary>
            Converts a given relative path and a given base path to an absoulte path
            by combining to the two together and calling <see cref="M:System.IO.Path.GetFullPath(System.String)"/>().
            </summary>
            <param name="basePath">The base path</param>
            <param name="relativePath">The relative path</param>
            <returns>The combined and rooted absolute full path</returns>
        </member>
        <member name="M:HSS.IO.FileUtil.ReplaceBasePath(System.String,System.String,System.String)">
            <summary>
            Replaces the <paramref name="fileBasePath"/> portion of <paramref name="fileFullPath"/> with <paramref name="newBasePath"/>.
            </summary>
            <param name="fileFullPath">The full file path to be changed</param>
            <param name="fileBasePath">The files base path to be replaced</param>
            <param name="newBasePath">The new base path for the file</param>
            <returns>The modified file path using the new base path unless the fileBasePath does not match, then returns
            the fileFullPath; otherwise simply returns the newBasePath if fileFullPath equals fileBasePath</returns>
        </member>
        <member name="M:HSS.IO.FileUtil.RenameBaseDirectory(System.String,System.String,System.String)">
            <summary>
            Renames the base directory for a given file
            </summary>
            <param name="fileName">The file to rebase</param>
            <param name="oldDirectory">The current directory</param>
            <param name="newDirectory">The new directory</param>
            <returns>Returns the FileName with the new base directory</returns>
        </member>
        <member name="M:HSS.IO.FileUtil.IsBaseDirectory(System.String,System.String)">
            <summary>
            Checks to see if the base directory for <paramref name="testDirectory"/> is equal to the <paramref name="baseDirectory"/> provided
            </summary>
            <param name="baseDirectory">The base to compare</param>
            <param name="testDirectory">The directory to check</param>
            <returns>true of the testDirectory has the same baseDirectory</returns>
        </member>
        <member name="M:HSS.IO.FileUtil.IsFileAvailable(System.String)">
            <summary>
            Determines if a file is accessible and can be opened for read access
            </summary>
            <param name="fileName">The file name and location</param>
            <returns>true if the file can be opened</returns>
            <exception cref="T:System.UnauthorizedAccessException">Rethrown if encoutered</exception>
            <exception cref="T:System.Security.SecurityException">Rethrown if encoutered</exception>
        </member>
        <member name="M:HSS.IO.FileUtil.IsFileAvailable(System.String,System.IO.FileAccess)">
            <summary>
            Determines if a file is accessible and can be opened with the access method specified
            </summary>
            <param name="fileName">The file name and location</param>
            <param name="fileAccessMethod">The File Access method used to evaluate a file</param>
            <returns>true if the file can be opened</returns>
            <exception cref="T:System.UnauthorizedAccessException">Rethrown if encoutered</exception>
            <exception cref="T:System.Security.SecurityException">Rethrown if encoutered</exception>
        </member>
        <member name="M:HSS.IO.FileUtil.IsFileAvailable(System.String,System.IO.FileMode,System.IO.FileAccess)">
            <summary>
            Determines if a file is accessible and can be opened using the desired FileMode 
            and FileAccess parameters
            </summary>
            <param name="fileName">The file name and location</param>
            <param name="accessMode">The desired FileMode</param>
            <param name="fileAccessMethod">The File Access method used to evaluate a file</param> 
            <returns>true if the file can be opened</returns>
            <exception cref="T:System.UnauthorizedAccessException">Rethrown if encoutered</exception>
            <exception cref="T:System.Security.SecurityException">Rethrown if encoutered</exception>
        </member>
        <member name="M:HSS.IO.FileUtil.IsUrl(System.String)">
            <summary>
            Determines if a path is a URL by looking for a ':' anywhere after the first two characters.
            </summary>
            <param name="path">The path to check</param>
            <returns>true if the path is a Url; otherwise false</returns>
        </member>
        <member name="M:HSS.IO.FileUtil.IsEqualFileName(System.String,System.String)">
            <summary>
            Determines if the two file names are equal
            </summary>
            <param name="fileName1">The first file name to check</param>
            <param name="fileName2">The second file name to check</param>
            <returns>true if the file names are equal; otherwise false</returns>
        </member>
        <member name="M:HSS.IO.FileUtil.IsValidFileName(System.String)">
            <summary>
            Checks if a file name is valid.
            </summary>
            <param name="fileName">the file name to check</param>
            <returns>true if the file name is valid; otherwise false</returns>
        </member>
        <member name="M:HSS.IO.FileUtil.IsValidDirectoryName(System.String)">
            <summary>
            Checks that a single directory name (not the full path) is valid.
            </summary>
            <param name="name">The name to check</param>
            <returns>true if the name is a valid directory name; otherwise false</returns>
        </member>
        <member name="M:HSS.IO.FileUtil.IsDirectory(System.String)">
            <summary>
            Checks if a file name is a directory
            </summary>
            <param name="fileName">The file name to check</param>
            <returns>true if the file name is a directory; otherwise false</returns>
        </member>
        <member name="M:HSS.IO.FileUtil.PathStartsWith(System.String,System.String)">
            <summary>
            Determines whether the beginning of the specified <paramref name="path"/> matches the provided <paramref name="basePath"/>
            </summary>
            <param name="basePath">The Directory Path that serves as the base path</param>
            <param name="path">The File or Directory to check</param>
            <returns>true if the <paramref name="path"/> starts with the base path; otherwise false</returns>
            <remarks>Before comparing the paths, a call to <c>Path.GetFullPath()</c> is called on both values
            to ensure they're both absolute and rooted, such as "\test\data" becomes "c:\test\data".</remarks>
        </member>
        <member name="M:HSS.IO.FileUtil.MatchesPattern(System.String,System.String)">
            <summary>
            Determines if the provided file name matches the given patter
            </summary>
            <param name="fileName">The file name to check</param>
            <param name="pattern">The patter used for comparison</param>
            <returns>true if the file name matches the pattern</returns>
        </member>
        <member name="M:HSS.IO.FileUtil.FileCompare(System.String,System.String)">
            <summary>
            Compare two files to determine if they are equal
            </summary>
            <param name="file1">The first file used in the comparison</param>
            <param name="file2">The second file used in the comparison</param>
            <returns>true if the files are the same; otherwise false</returns>
        </member>
        <member name="M:HSS.IO.FileUtil.EnsureDirectoryExist(System.String)">
            <summary>
            Evaluates if a directory exists and if not, creates the directory
            </summary>
            <param name="directory">The path to ensure exists</param>
        </member>
        <member name="M:HSS.IO.FileUtil.EnsureDirectoryExist(System.String,System.String,System.Security.AccessControl.FileSystemRights)">
            <summary>
            Evaluates if a directory exists and if not, creates the directory. In addition allows you to specify Security access for the directory.
            </summary>
            <param name="directory">The path to ensure exists</param>
            <param name="identity">The identity to allow access (i.e., Users or Administrators)</param>
            <param name="rights">The rights to assign</param>
            <remarks>Provide for the abillity to set the access permission to the directory. If the Folder already exists, then will append the new access security</remarks>
        </member>
        <member name="M:HSS.IO.FileUtil.EnsureDirectoryExist(System.String,System.String,System.Security.AccessControl.FileSystemRights,System.Security.AccessControl.AccessControlType)">
            <summary>
            Evaluates if a directory exists and if not, creates the directory. In addition allows you to specify Security access for the directory.
            </summary>
            <param name="directory">The path to ensure exists</param>
            <param name="identity">The identity to allow access (i.e., Users or Administrators)</param>
            <param name="rights">The rights to assign</param>
            <param name="accessControl">The control for the given rights, Allow or Deny</param>
            <remarks>Provide for the abillity to set the access permission to the directory. If the Folder already exists, then will append the new access security</remarks>
        </member>
        <member name="M:HSS.IO.FileUtil.DeepCopy(System.String,System.String,System.Boolean)">
            <summary>
            Performs a deep copy of all directories and files, optionally specifying whether or not to overwrite existing files
            </summary>
            <param name="sourceDirectory">The directory to copy from</param>
            <param name="destinationDirectory">The directory to copy to</param>
            <param name="overwrite">Indicates whether or not to overwrite existing files</param>
        </member>
        <member name="M:HSS.IO.FileUtil.SearchDirectory(System.String,System.String,System.Boolean,System.Boolean)">
            <summary>
            Finds all files which are valid for the <paramref name="fileMask"/> in the specified <paramref name="directory"/>
            and all subdirectories (if <paramref name="searchSubdirectories"/> is true).
            If <paramref name="ignoreHidden"/> is true, hidden files and folders are ignored.
            </summary>
            <param name="directory">The directory the search in</param>
            <param name="fileMask">The mask criteria for finding files</param>
            <param name="searchSubdirectories">Indicates whether or not to search sub-directories</param>
            <param name="ignoreHidden">Indicates whether or not to ignore (exclude) hidden files and folders</param>
            <returns>A List&lt;string&gt; collection containing the files found if any</returns>
        </member>
        <member name="M:HSS.IO.FileUtil.SearchDirectory(System.String,System.String,System.Boolean)">
            <summary>
            Finds all files which are valid for the <paramref name="fileMask"/> in the specified <paramref name="directory"/>
            and all subdirectories (if <paramref name="searchSubdirectories"/> is true).
            </summary>
            <param name="directory">The directory the search in</param>
            <param name="fileMask">The mask criteria for finding files</param>
            <param name="searchSubdirectories">Indicates whether or not to search sub-directories</param>
            <returns>A List&lt;string&gt; collection containing the files found if any</returns>
        </member>
        <member name="M:HSS.IO.FileUtil.SearchDirectory(System.String,System.String)">
            <summary>
            Finds all files which are valid for the <paramref name="fileMask"/> in the specified <paramref name="directory"/>.
            </summary>
            <param name="directory">The directory the search in</param>
            <param name="fileMask">The mask criteria for finding files</param>
            <returns>A List&lt;string&gt; collection containing the files found if any</returns>
        </member>
        <member name="M:HSS.IO.FileUtil.SearchDirectory(System.String,System.String,System.Collections.Generic.List{System.String},System.Boolean,System.Boolean)">
            <summary>
            Finds all files which are valid for the <paramref name="fileMask"/> in the specified <paramref name="directory"/>
            and all subdirectories (if <paramref name="searchSubdirectories"/> is true).
            The found files are added to the List&lt;string&gt; <paramref name="collection"/>.
            If <paramref name="ignoreHidden"/> is true, hidden files and folders are ignored.
            </summary>
            <param name="collection">The collection to populate with found files</param>
            <param name="directory">The directory the search in</param>
            <param name="fileMask">The mask criteria for finding files</param>
            <param name="ignoreHidden">Indicates whether or not to ignore (exclude) hidden files and folders</param>
            <param name="searchSubdirectories">Indicate whether or not to search sub-directories</param>
        </member>
        <member name="T:HSS.Logging.LogCategory">
            <summary>
            Contains the name and id of a Log Category.
            </summary>
        </member>
        <member name="T:HSS.Data.IDataContainer">
            <summary>
            Is the base interface for objects that contain additional properties representing a data model, and can
            be used by Data Transfer/Storage Mechanisms to share, transfer or otherwise communicate data.
            </summary>
        </member>
        <member name="P:HSS.Data.IDataContainer.Id">
            <summary>
            The Unique Id for the Data contained in an instance of this class.
            </summary>
        </member>
        <member name="P:HSS.Data.IDataContainer.Name">
            <summary>
            The friendly name to refer to this instance by.
            </summary>
        </member>
        <member name="P:HSS.Data.IDataContainer.Data">
            <summary>
            The data contained in this object
            </summary>
        </member>
        <member name="T:HSS.Data.IDataEntity">
            <summary>
            IDataEntity marks an object with the minimal requirements to be able to participate in the DataAccessService services.
            </summary>
        </member>
        <member name="M:HSS.Data.IDataEntity.Load(System.Data.IDataRecord)">
            <summary>
            Implement this method to populate your Object Model class from a <see cref="T:System.Data.IDataRecord"/>
            </summary>
            <param name="dr">A <see cref="T:System.Data.IDataRecord"/> containing the data for this Entity</param>
        </member>
        <member name="M:HSS.Logging.LogCategory.#ctor">
            <summary>
            Constructor
            </summary>
        </member>
        <member name="M:HSS.Logging.LogCategory.#ctor(System.Data.IDataRecord)">
            <summary>
            Constructor
            </summary>
            <param name="dr">The <see cref="T:System.Data.IDataRecord"/> to construct this instance from.</param>
        </member>
        <member name="M:HSS.Logging.LogCategory.Load(System.Data.IDataRecord)">
            <summary>
            Populates this instance from an <see cref="T:System.Data.IDataRecord"/>.
            </summary>
            <param name="dr">The <see cref="T:System.Data.IDataRecord"/> to populate this instance from.</param>
        </member>
        <member name="P:HSS.Logging.LogCategory.Id">
            <summary>
            Gets or sets the Id value.
            </summary>
        </member>
        <member name="P:HSS.Logging.LogCategory.Name">
            <summary>
            Gets or sets the Name value.
            </summary>
        </member>
        <member name="P:HSS.Logging.LogCategory.Data">
            <summary>
            Gets this instance as an object.
            </summary>
        </member>
        <member name="T:HSS.Security.Cryptography.AES">
            <summary>
            An AES Encryption Helper that relies on RSA Exhange Public/Private Keys from either the Machine or UserProfile KeyStores. This class is not thread-safe.
            </summary>
            <remarks>
            <para>
            Features of AES are implemented as follows...
            </para>
            <list type="table">
            <listheader>
            <term>Feature</term>
            <description>Description</description>
            </listheader>
            <item><term>KeySize</term><description>256 bit</description></item>
            <item><term>CodeBook</term><description>CBC - Cipher-Block-Chaining</description></item>
            <item><term>Key Management</term><description>RSA Exhange Public/Private Keys</description></item>
            <item><term>MachineStore/UserProfile</term><description>When accessing a KeyContainer, indicates the KeyStore (default is the UserProfile)</description></item>
            </list>
            </remarks>
        </member>
        <member name="F:HSS.Security.Cryptography.AES.DEFAULT_MIN_PASSWORD_LENGTH">
            <summary>
            The default minimum password length when generating a random password.
            </summary>
        </member>
        <member name="F:HSS.Security.Cryptography.AES.DEFAULT_MAX_PASSWORD_LENGTH">
            <summary>
            The default maximum password length when generating a random password.
            </summary>
        </member>
        <member name="F:HSS.Security.Cryptography.AES.PASSWORD_CHARS_LCASE">
            <summary>
            A list of lower case characters used when generating a random password.
            </summary>
        </member>
        <member name="F:HSS.Security.Cryptography.AES.PASSWORD_CHARS_UCASE">
            <summary>
            A list of upper case characters used when generating a random password.
            </summary>
        </member>
        <member name="F:HSS.Security.Cryptography.AES.PASSWORD_CHARS_NUMERIC">
            <summary>
            /// A list of numbers used when generating a random password.		
            </summary>
        </member>
        <member name="F:HSS.Security.Cryptography.AES.PASSWORD_CHARS_SPECIAL">
            <summary>
            A list of special characters used when generating a random password.
            </summary>
        </member>
        <member name="M:HSS.Security.Cryptography.AES.ConfigureAccess(System.Boolean,System.Boolean)">
            <summary>
            Configure AES by indicating what KeyStore to use, and whether or not 
            to allow prompting (if necessary); this method can be called more than
            once to change the state when making subsequent calls to Encrpt/Decrypt
            <para>
            NOTE: When using MachineStore, requests to encrypt/decrypt require the calling user to have elevated privelages.
            </para>
            </summary>
            <param name="useMachineStore"></param>
            <param name="allowPrompt"></param>
            <remarks>
            Call this method to specify the state for subsequent calls to Encrpt/Decrypt
            </remarks>
        </member>
        <member name="M:HSS.Security.Cryptography.AES.CompareHash(System.Byte[],System.Byte[])">
            <summary>
            Compares two Hash Values
            </summary>
            <param name="hash1">Orignial Hash</param>
            <param name="hash2">Compare Hash</param>
            <returns>true if both Hash Values are equal</returns>
        </member>
        <member name="M:HSS.Security.Cryptography.AES.Encrypt(System.String)">
            <summary>
            Encrypt a string of data using the <see cref="P:HSS.Security.Cryptography.AES.DefaultKeyName"/>
            </summary>
            <param name="plainString">The plain string to encrypt.</param>
            <returns>The encrypted content as a BASE64 string</returns>
            <exception cref="T:System.ArgumentException">The DefaultKeyName property must be set.</exception>
        </member>
        <member name="M:HSS.Security.Cryptography.AES.Encrypt(System.String,System.String)">
            <summary>
            Encrypt a string of data
            </summary>
            <param name="plainString">The plain string to encrypt.</param>
            <param name="keyName">The name of the Key to use.</param>
            <returns>The encrypted content as a BASE64 string</returns>
            <exception cref="T:System.ArgumentException">keyName equals null or is empty. You must provide the name of the KeyContainer to use for Encryption</exception>
            <exception cref="T:System.ArgumentException">Could find a Container with the KeyName provided</exception>
        </member>
        <member name="M:HSS.Security.Cryptography.AES.Encrypt(System.String,System.Byte[])">
            <summary>
            Encrypt a string of data
            </summary>
            <param name="plainString">The plain string to encrypt.</param>
            <param name="publicKey">The RSA Public Key information used to 
            encrypt the AES Key. Should be the CspBlob.</param>
            <returns>The encrypted content as a BASE64 string</returns>
        </member>
        <member name="M:HSS.Security.Cryptography.AES.Encrypt(System.String,System.Security.Cryptography.RSACryptoServiceProvider)">
            <summary>
            Encrypt a string of data
            </summary>
            <param name="plainString">The plain string to encrypt.</param>
            <param name="rsa">The RSACryptoServiceProvider used to encrypt the AES Key.</param>
            <returns>The encrypted content as a BASE64 string</returns>
        </member>
        <member name="M:HSS.Security.Cryptography.AES.Encrypt(System.Byte[])">
            <summary>
            Encrypt an array of bytes using the <see cref="P:HSS.Security.Cryptography.AES.DefaultKeyName"/>
            </summary>
            <param name="unencryptedBytes">The data to encrypt.</param>
            <returns>The encrypted byte[]</returns>
            <exception cref="T:System.ArgumentException">The KeyName property must be set.</exception>
        </member>
        <member name="M:HSS.Security.Cryptography.AES.Encrypt(System.Byte[],System.String)">
            <summary>
            Encrypt an array of bytes
            </summary>
            <param name="unencryptedBytes">The data to encrypt.</param>
            <param name="keyName">The name of the Key to use.</param>
            <returns>The encrypted byte[]</returns>
            <exception cref="T:System.ArgumentException">keyName equals null or is empty. You must provide the name of the KeyContainer to use for Encryption</exception>
            <exception cref="T:System.ArgumentException">Could find a Container with the KeyName provided</exception>
        </member>
        <member name="M:HSS.Security.Cryptography.AES.Encrypt(System.Byte[],System.Byte[])">
            <summary>
            Encrypt an array of bytes
            </summary>
            <param name="unencryptedBytes">The data to encrypt.</param>
            <param name="publicKey">The RSA Public Key information used to 
            encrypt the data. Should be the CspBlob.</param>
            <returns>The encrypted byte[]</returns>
        </member>
        <member name="M:HSS.Security.Cryptography.AES.Encrypt(System.Byte[],System.Security.Cryptography.RSACryptoServiceProvider)">
            <summary>
            Encrypt an array of bytes
            </summary>
            <param name="unencryptedBytes">The data to encrypt.</param>
            <param name="rsa">The RSACryptoServiceProvider used for encryption.</param>
            <returns>The encrypted Stream</returns>
        </member>
        <member name="M:HSS.Security.Cryptography.AES.Encrypt``1(System.IO.Stream)">
            <summary>
            Encrypt a MemoryStream using the <see cref="P:HSS.Security.Cryptography.AES.DefaultKeyName"/>
            </summary>
            <typeparam name="TStream">The type of stream to return.</typeparam>
            <returns>A <typeparamref name="TStream"/> containing the encrypted data.</returns>
            <returns>The encrypted MemoryStream</returns>
            <exception cref="T:System.ArgumentException">The DefaultKeyName property must be set.</exception>
        </member>
        <member name="M:HSS.Security.Cryptography.AES.Encrypt``1(System.IO.Stream,System.String)">
            <summary>
            Encrypt a MemoryStream
            </summary>
            <typeparam name="TStream">The type of stream to return.</typeparam>
            <param name="unencryptedStream">The data to encrypt.</param>
            <param name="keyName">The name of the Key to use.</param>
            <returns>A <typeparamref name="TStream"/> containing the encrypted data.</returns>
            <exception cref="T:System.ArgumentException">keyName equals null or is empty. You must provide the name of the KeyContainer to use for Encryption</exception>
            <exception cref="T:System.ArgumentException">Could find a Container with the KeyName provided</exception>
        </member>
        <member name="M:HSS.Security.Cryptography.AES.Encrypt``1(System.IO.Stream,System.Byte[])">
            <summary>
            Encrypt a MemoryStream
            </summary>
            <typeparam name="TStream">The type of stream to return.</typeparam>
            <param name="unencryptedStream">The data to encrypt.</param>
            <param name="publicKey">The RSA Public Key information used to 
            encrypt the AES Key. Should be the CspBlob.</param>
            <returns>A <typeparamref name="TStream"/> containing the encrypted data.</returns>
        </member>
        <member name="M:HSS.Security.Cryptography.AES.Encrypt``1(System.IO.Stream,System.Security.Cryptography.RSACryptoServiceProvider)">
            <summary>
            Encrypt a stream of data
            </summary>
            <typeparam name="TStream">The type of stream to return.</typeparam>
            <param name="unencryptedStream">The stream to encrypt.</param>
            <param name="rsa">The RSACryptoServiceProvider used for encryption.</param>
            <returns>A <typeparamref name="TStream"/> containing the encrypted data.</returns>
        </member>
        <member name="M:HSS.Security.Cryptography.AES.SharedKeyEncrypt(System.String,System.Byte[],System.Byte[])">
            <summary>
            Encrypt a plain string using a shared Key without leveraging RSA Public/Private key encryption.
            </summary>
            <remarks>This method is typical for applications where a public/private key cannot be used.</remarks>
            <param name="plainString">The plain string to encrypt.</param>
            <param name="key">The secret key used for encryption.</param>
            <param name="iv">The initialization vector (IV) to use for encryption.</param>
            <returns>A Base64 string containing the encrypted data.</returns>
        </member>
        <member name="M:HSS.Security.Cryptography.AES.SharedKeyEncrypt(System.Byte[],System.Byte[],System.Byte[])">
            <summary>
            Encrypt a byte[] using a shared Key without leveraging RSA Public/Private key encryption.
            </summary>
            <remarks>This method is typical for applications where a public/private key cannot be used.</remarks>
            <param name="unencryptedBytes">The bytes to encrypt.</param>
            <param name="key">The secret key used for encryption.</param>
            <param name="iv">The initialization vector (IV) to use for encryption.</param>
            <returns>A byte[] containing the encrypted data.</returns>
        </member>
        <member name="M:HSS.Security.Cryptography.AES.SharedKeyEncrypt``1(System.IO.Stream,System.Byte[],System.Byte[])">
            <summary>
            Encrypt a Stream using a shared Key without leveraging RSA Public/Private key encryption.
            </summary>
            <remarks>This method is typical for applications where a public/private key cannot be used.</remarks>
            <typeparam name="TStream">The type of Stream to create.</typeparam>
            <param name="unencryptedStream">The data stream to encrypt.</param>
            <param name="key">The secret key used for encryption.</param>
            <param name="iv">The initialization vector (IV) to use for encryption.</param>
            <returns>A <typeparamref name="TStream"/> containing the encrypted data.</returns>
        </member>
        <member name="M:HSS.Security.Cryptography.AES.Decrypt(System.String)">
            <summary>
            Decrypt a string of encrypted text using the <see cref="P:HSS.Security.Cryptography.AES.DefaultKeyName"/>
            </summary>
            <param name="base64String">The BASE64 String containing the encrypted data.</param>
            <returns>The decrypted data</returns>
            <exception cref="T:System.ArgumentException">The DefaultKeyName property must be set.</exception>
        </member>
        <member name="M:HSS.Security.Cryptography.AES.Decrypt(System.String,System.String)">
            <summary>
            Decrypt a string of encrypted text
            </summary>
            <param name="base64String">The BASE64 String containing the encrypted data.</param>
            <param name="keyName">The name of the Key to use.</param>
            <returns>The decrypted data</returns>
            <exception cref="T:System.ArgumentException">keyName equals null or is empty. You must provide the name of the KeyContainer to use for Encryption</exception>
            <exception cref="T:System.ArgumentException">Could find a Container with the KeyName provided</exception>
        </member>
        <member name="M:HSS.Security.Cryptography.AES.Decrypt(System.String,System.Byte[])">
            <summary>
            Decrypt a string of encrypted text
            </summary>
            <param name="base64String">The BASE64 String containing the encrypted data.</param>
            <param name="privateKey">The RSA Private Key information used to
            decrypt the byte array. Should be the CspBlob.</param>
            <returns>The decrypted data</returns>
        </member>
        <member name="M:HSS.Security.Cryptography.AES.Decrypt(System.String,System.Security.Cryptography.RSACryptoServiceProvider)">
            <summary>
            Decrypt a string of encrypted text
            </summary>
            <param name="base64String">The BASE64 String containing the encrypted data.</param>
            <param name="rsa">The RSACryptoServiceProvider used to decrypt the AES Key.</param>
            <returns>The decrypted data</returns>
        </member>
        <member name="M:HSS.Security.Cryptography.AES.Decrypt(System.Byte[])">
            <summary>
            Decrypt a byte array of encrypted text using the <see cref="P:HSS.Security.Cryptography.AES.DefaultKeyName"/>
            </summary>
            <param name="encryptedBytes">The byte array containing the encrypted data.</param>
            <returns>The decrypted data</returns>
            <exception cref="T:System.ArgumentException">The DefaultKeyName property must be set.</exception>
        </member>
        <member name="M:HSS.Security.Cryptography.AES.Decrypt(System.Byte[],System.String)">
            <summary>
            Decrypt a byte array of encrypted text
            </summary>
            <param name="encryptedBytes">The byte array containing the encrypted data.</param>
            <param name="keyName">The name of the Key to use.</param>
            <returns>The decrypted data</returns>
            <exception cref="T:System.ArgumentException">keyName equals null or is empty. You must provide the name of the KeyContainer to use for Encryption</exception>
            <exception cref="T:System.ArgumentException">Could find a Container with the KeyName provided</exception>
        </member>
        <member name="M:HSS.Security.Cryptography.AES.Decrypt(System.Byte[],System.Byte[])">
            <summary>
            Decrypt a byte array of encrypted text
            </summary>
            <param name="encryptedBytes">The byte array containing the encrypted data.</param>
            <param name="privateKey">The RSA Private Key information used to
            decrypt the byte array. Should be the CspBlob.</param>
            <returns>The decrypted data</returns>
        </member>
        <member name="M:HSS.Security.Cryptography.AES.Decrypt(System.Byte[],System.Security.Cryptography.RSACryptoServiceProvider)">
            <summary>
            Decrypt a byte array of encrypted text
            </summary>
            <param name="encryptedBytes">The byte array containing the encrypted data.</param>
            <param name="rsa">The RSACryptoServiceProvider used to decrypt the AES Key.</param>
            <returns>The decrypted data</returns>
        </member>
        <member name="M:HSS.Security.Cryptography.AES.Decrypt``1(System.IO.Stream)">
            <summary>
            Decrypt a memorystream of encrypted data using the <see cref="P:HSS.Security.Cryptography.AES.DefaultKeyName"/>
            </summary>
            <typeparam name="TStream">The type of Stream to return.</typeparam>
            <param name="encryptedStream">The stream containing the encrypted data.</param>
            <returns>A <typeparamref name="TStream"/> containing the decrypted data.</returns>
            <exception cref="T:System.ArgumentException">The DefaultKeyName property must be set.</exception>
        </member>
        <member name="M:HSS.Security.Cryptography.AES.Decrypt``1(System.IO.Stream,System.String)">
            <summary>
            Decrypt a memorystream of encrypted data
            </summary>
            <typeparam name="TStream">The type of Stream to return.</typeparam>
            <param name="encryptedStream">The stream containing the encrypted data.</param>
            <param name="keyName">The name of the Key to use.</param>
            <returns>A <typeparamref name="TStream"/> containing the decrypted data.</returns>
            <exception cref="T:System.ArgumentException">keyName equals null or is empty. You must provide the name of the KeyContainer to use for Encryption</exception>
            <exception cref="T:System.ArgumentException">Could find a Container with the KeyName provided</exception>
        </member>
        <member name="M:HSS.Security.Cryptography.AES.Decrypt``1(System.IO.Stream,System.Byte[])">
            <summary>
            Decrypt a memorystream of encrypted data
            </summary>
            <typeparam name="TStream">The type of Stream to return.</typeparam>
            <param name="encryptedStream">The stream containing the encrypted data.</param>
            <param name="privateKey">The RSA Private Key information used to
            decrypt the byte array. Should be the CspBlob.</param>
            <returns>A <typeparamref name="TStream"/> containing the decrypted data.</returns>
        </member>
        <member name="M:HSS.Security.Cryptography.AES.Decrypt``1(System.IO.Stream,System.Security.Cryptography.RSACryptoServiceProvider)">
            <summary>
            Decrypt a stream of encrypted data
            </summary>
            <typeparam name="TStream">The type of Stream to return.</typeparam>
            <param name="encryptedStream">The stream to unencrypt.</param>
            <param name="rsa">The RSACryptoServiceProvider used to decrypt the AES Key.</param>
            <returns>A <typeparamref name="TStream"/> containing the decrypted data.</returns>
        </member>
        <member name="M:HSS.Security.Cryptography.AES.SharedKeyDecrypt(System.String,System.Byte[],System.Byte[])">
            <summary>
            Decrypt a BASE64 string using a shared Key without leveraging RSA Public/Private key encryption.
            </summary>
            <remarks>This method is typical for applications where a public/private key cannot be used.</remarks>
            <param name="base64String">The BASE64 String containing the encrypted data.</param>
            <param name="key">The secret key used for encryption.</param>
            <param name="iv">The initialization vector (IV) used for encryption.</param>
            <returns>A string containing the decrypted data.</returns>
        </member>
        <member name="M:HSS.Security.Cryptography.AES.SharedKeyDecrypt(System.Byte[],System.Byte[],System.Byte[])">
            <summary>
            Decrypt a byte[] using a shared Key without leveraging RSA Public/Private key encryption.
            </summary>
            <remarks>This method is typical for applications where a public/private key cannot be used.</remarks>
            <param name="encryptedBytes">The bytes to decrypt.</param>
            <param name="key">The secret key used for encryption.</param>
            <param name="iv">The initialization vector (IV) used for encryption.</param>
            <returns>A byte[] containing the decrypted data.</returns>
        </member>
        <member name="M:HSS.Security.Cryptography.AES.SharedKeyDecrypt``1(System.IO.Stream,System.Byte[],System.Byte[])">
            <summary>
            Decrypt a Stream using a shared Key without leveraging RSA Public/Private key encryption.
            </summary>
            <typeparam name="TStream">The type of Stream to return.</typeparam>
            <param name="encryptedStream">The stream to decrypt.</param>
            <param name="key">The secret key used for encryption.</param>
            <param name="iv">The initialization vector (IV) used for encryption.</param>
            <returns>A <typeparamref name="TStream"/> containing the decrypted data.</returns>
        </member>
        <member name="M:HSS.Security.Cryptography.AES.GenerateKey(System.Byte[],System.Byte[],System.Int32,System.Int32)">
            <summary>
            Derive a Key from a Password and Salt.
            </summary>
            <remarks>
            The GenerateKey method implements PBKDF2 functionality by using a pseudorandom number generator 
            based on HMACSHA1. The GenerateKey method takes a password, a salt, and an iteration count, and 
            then generates keys through calls to the Rfc2898DeriveBytes GetBytes method.
            </remarks>
            <param name="password">The Password used to generate the Key</param>
            <param name="salt">The Value to prepend the Password with for uniqueness</param>
            <param name="iterations">The number of Iterations in generating the key</param>
            <param name="keySize">The number of pseudo-random key bytes to generate.</param>
            <returns>Returns a pseudo-random key from a password, salt and iteration count.</returns>
        </member>
        <member name="M:HSS.Security.Cryptography.AES.GenerateKey(System.String,System.Byte[],System.Int32,System.Int32)">
            <summary>
            Derive a Key from a Password and Salt.
            </summary>
            <remarks>
            The GenerateKey method implements PBKDF2 functionality by using a pseudorandom number generator 
            based on HMACSHA1. The GenerateKey method takes a password, a salt, and an iteration count, and 
            then generates keys through calls to the Rfc2898DeriveBytes GetBytes method.
            </remarks>
            <param name="password">The Password used to generate the Key</param>
            <param name="salt">The Value to prepend the Password with for uniqueness</param>
            <param name="iterations">The number of Iterations in generating the key</param>
            <param name="keySize">The number of pseudo-random key bytes to generate.</param>
            <returns>Returns a pseudo-random key from a password, salt and iteration count.</returns>
        </member>
        <member name="M:HSS.Security.Cryptography.AES.GenerateKey(System.String,System.String,System.Int32,System.Int32)">
            <summary>
            Derive a Key from a Password and Salt.
            </summary>
            <remarks>
            The GenerateKey method implements PBKDF2 functionality by using a pseudorandom number generator 
            based on HMACSHA1. The GenerateKey method takes a password, a salt, and an iteration count, and 
            then generates keys through calls to the Rfc2898DeriveBytes GetBytes method.
            </remarks>
            <param name="password">The Password used to generate the Key</param>
            <param name="salt">The Value to prepend the Password with for uniqueness</param>
            <param name="iterations">The number of Iterations in generating the key</param>
            <param name="keySize">The number of pseudo-random key bytes to generate.</param>
            <returns>Returns a pseudo-random key from a password, salt and iteration count.</returns>
        </member>
        <member name="M:HSS.Security.Cryptography.AES.GenerateRandom">
            <summary>
            Generates a random password.
            </summary>
            <returns>
            Randomly generated password.
            </returns>
            <remarks>
            The length of the generated password will be determined at
            random. It will be no shorter than the minimum default and
            no longer than maximum default.
            </remarks>
        </member>
        <member name="M:HSS.Security.Cryptography.AES.GenerateRandom(System.Int32)">
            <summary>
            Generates a random password of the exact length.
            </summary>
            <param name="length">
            Exact password length.
            </param>
            <returns>
            Randomly generated password.
            </returns>
        </member>
        <member name="M:HSS.Security.Cryptography.AES.GenerateRandom(System.Int32,System.Int32)">
            <summary>
            Generates a random password.
            </summary>
            <param name="minLength">
            Minimum password length.
            </param>
            <param name="maxLength">
            Maximum password length.
            </param>
            <returns>
            Randomly generated password.
            </returns>
            <remarks>
            The length of the generated password will be determined at
            random and it will fall with the range determined by the
            function parameters.
            </remarks>
        </member>
        <member name="M:HSS.Security.Cryptography.AES.initAES">
            <summary>
            initalizes the AES Class.
            </summary>
            <returns>An instance of AesManaged</returns>
        </member>
        <member name="M:HSS.Security.Cryptography.AES.InitializeKeyManger">
            <summary>
            Initialize the KeyManager
            </summary>
        </member>
        <member name="P:HSS.Security.Cryptography.AES.DefaultKeyName">
            <summary>
            The name of the default Key Container to use when not specifying
            explicity the name of a key container to use; see <see cref="M:HSS.Security.Cryptography.AES.ConfigureAccess(System.Boolean,System.Boolean)"/>
            </summary>
        </member>
        <member name="P:HSS.Security.Cryptography.AES.UseMachineStore">
            <summary>
            Gets whether or not to use the MachineStore versus the UserProfile when accessing the KeyStore (default: false) see <see cref="M:HSS.Security.Cryptography.AES.ConfigureAccess(System.Boolean,System.Boolean)"/>
            </summary>
        </member>
        <member name="P:HSS.Security.Cryptography.AES.AllowPrompt">
            <summary>
            Gets whether or not to allow prompting (if necessary) when accessing a KeyStore (default: false) see <see cref="M:HSS.Security.Cryptography.AES.ConfigureAccess(System.Boolean,System.Boolean)"/>
            </summary>
        </member>
        <member name="T:HSS.ObjectSerialization">
            <summary>
            Serialization
            </summary>
        </member>
        <member name="M:HSS.ObjectSerialization.ToXml(System.Object)">
            <summary>
            Serializes an object to xml.
            </summary>
            <param name="value">The object to serialize to xml.</param>
            <returns>A string containing the xml</returns>
        </member>
        <member name="M:HSS.ObjectSerialization.ToXmlFile(System.Object,System.String)">
            <summary>
            Serializes an object to xml and saves the resulting Xml string to the file requested.
            </summary>
            <param name="value">The object to serialize to xml.</param>
            <param name="fileName">The file name and path where to write the xml.</param>
        </member>
        <member name="M:HSS.ObjectSerialization.FromXml(System.IO.Stream,System.Type)">
            <summary>
            Gets an instance of an object from a Stream
            </summary>
            <param name="xmlStream">A Stream containing the xml to deserialize from</param>
            <param name="instanceType">The Type to return</param>
            <returns>The Object Instance</returns>
        </member>
        <member name="M:HSS.ObjectSerialization.FromXml(System.IO.FileInfo,System.Type)">
            <summary>
            Gets an instance of an object from an xml File
            </summary>
            <param name="filePath">The path to the xml file</param>
            <param name="instanceType">The Type to return</param>
            <returns>The Object Instance</returns>
        </member>
        <member name="M:HSS.ObjectSerialization.FromXml(System.String,System.Type)">
            <summary>
            Gets an instance of an object from an xml File
            </summary>
            <param name="xml">The Raw xml</param>
            <param name="instanceType">The Type to return</param>
            <returns>The Object Instance</returns>
        </member>
        <member name="M:HSS.ObjectSerialization.FromXml(System.Xml.XmlDocument,System.Type)">
            <summary>
            Gets an instance of an object from an xml File
            </summary>
            <param name="xmlDocument">The XmlDocument</param>
            <param name="instanceType">The Type to return</param>
            <returns>The Object Instance</returns>
        </member>
        <member name="M:HSS.ObjectSerialization.FromXml(System.IO.FileInfo,System.Type,System.String)">
            <summary>
            Gets an instance of an object from an xml File
            </summary>
            <param name="filePath">The path to the xml file</param>
            <param name="instanceType">The Type to return</param>
            <param name="xsdResourceSchema">The name of the Resource that contains the XsdSchema to use to validate the xml. This is not required.</param>
            <returns>The Object Instance</returns>
        </member>
        <member name="M:HSS.ObjectSerialization.FromXml(System.String,System.Type,System.String)">
            <summary>
            Gets an instance of an object from an xml File
            </summary>
            <param name="xml">The Raw xml</param>
            <param name="instanceType">The Type to return</param>
            <param name="xsdResourceSchema">The name of the Resource that contains the XsdSchema to use to validate the xml. This is not required.</param>
            <returns>The Object Instance</returns>
        </member>
        <member name="M:HSS.ObjectSerialization.FromXml(System.Xml.XmlDocument,System.Type,System.String)">
            <summary>
            Gets an instance of an object from an xml File
            </summary>
            <param name="xmlDocument">The XmlDocument</param>
            <param name="instanceType">The Type to return</param>
            <param name="xsdResourceSchema">The name of the Resource that contains the XsdSchema to use to validate the xml. This is not required.</param>
            <returns>The Object Instance</returns>
        </member>
        <member name="M:HSS.ObjectSerialization.FromXml``1(System.IO.Stream)">
            <summary>
            Gets an instance of an Object from a stream containing xml.
            </summary>
            <typeparam name="T">The Type of object to deserialize to</typeparam>
            <param name="xmlStream">A Stream containing the xml to deserialize from</param>
            <returns>The Object instance</returns>
        </member>
        <member name="M:HSS.ObjectSerialization.FromXml``1(System.IO.FileInfo)">
            <summary>
            Gets an instance of an Object from an xml file.
            </summary>
            <typeparam name="T">The Type of object to deserialize to</typeparam>
            <param name="filePath">The path to the xml file</param>
            <returns>The Object instance</returns>
        </member>
        <member name="M:HSS.ObjectSerialization.FromXml``1(System.String)">
            <summary>
            Gets an instance of an Object from raw xml
            </summary>
            <typeparam name="T">The Type of object to deserialize to</typeparam>
            <param name="xml">The Raw xml</param>
            <returns>The Object Instance</returns>
        </member>
        <member name="M:HSS.ObjectSerialization.FromXml``1(System.Xml.XmlDocument)">
            <summary>
            Gets an instance of an Object from an XmlDocument
            </summary>
            <typeparam name="T">The Type of object to deserialize to</typeparam>
            <param name="xmlDoc">The XmlDocument</param>
            <returns>The Object of Type T</returns>
        </member>
        <member name="M:HSS.ObjectSerialization.FromXml``1(System.IO.FileInfo,System.String)">
            <summary>
            Gets an instance of an Object from an xml File
            </summary>
            <typeparam name="T">The Type of object to deserialize to</typeparam>
            <param name="filePath">The path to the xml file</param>
            <param name="xsdResourceSchema">The name of the Resource that contains the XsdSchema to use to validate the xml. This is not required.</param>
            <returns>The Object instance</returns>
        </member>
        <member name="M:HSS.ObjectSerialization.FromXml``1(System.String,System.String)">
            <summary>
            Gets an instance of an Object from raw xml
            </summary>
            <typeparam name="T">The Type of object to deserialize to</typeparam>
            <param name="xml">The Raw xml</param>
            <param name="xsdResourceSchema">The name of the Resource that contains the XsdSchema to use to validate the xml. This is not required.</param>
            <returns>The Object Instance</returns>
        </member>
        <member name="M:HSS.ObjectSerialization.FromXml``1(System.Xml.XmlDocument,System.String)">
            <summary>
            Gets an instance of an Object from an XmlDocument
            </summary>
            <typeparam name="T">The Type of object to deserialize to</typeparam>
            <param name="xmlDoc">The XmlDocument</param>
            <param name="xsdResourceSchema">The name of the Resource that contains the XsdSchema to use to validate the xml. This is not required.</param>
            <returns>The Object of Type T</returns>
        </member>
        <member name="M:HSS.ObjectSerialization.ValidateConfiguration(System.Xml.XmlNode,System.String)">
            <summary>
            Validate an xml section against a schema
            </summary>
            <param name="section">An XmlNode to validate against the specified schema</param>
            <param name="xsdResource">The name of the Resource that contains the XsdSchema to use to validate the xml</param>
            <exception cref="T:System.Configuration.ConfigurationErrorsException">The section passed was null; this is an unrecoverable error, there must be a section defined.</exception>
        </member>
        <member name="M:HSS.ObjectSerialization.ValidateConfiguration(System.Xml.XmlNode,System.Xml.XmlReader)">
            <summary>
            Validate an xml section against a schema
            </summary>
            <param name="xmlSection">An XmlNode to validate against the specified schema</param>
            <param name="schemaDocument">The schemaDocument to use to validate the xml</param>
            <exception cref="T:System.Configuration.ConfigurationErrorsException">The section passed was null; this is an unrecoverable error, there must be a section defined.</exception>
            <exception cref="T:System.Configuration.ConfigurationErrorsException">The schema document passed was null; this is an unrecoverable error.</exception>
        </member>
        <member name="M:HSS.ObjectSerialization.ValidationCallBack(System.Object,System.Xml.Schema.ValidationEventArgs)">
            <summary>
            ValidationCallBack
            </summary>
            <param name="sender"></param>
            <param name="args"></param>
        </member>
        <member name="M:HSS.ObjectSerialization.ToMemoryStream(System.Object)">
            <summary>
            Serializes an object using a BinaryFormatter.
            </summary>
            <param name="value">The object to serialize to binaryData</param>
            <returns>A MemoryStream containing the binaryData</returns>
            <remarks>Use the <see cref="T:System.Runtime.Serialization.Formatters.Binary.BinaryFormatter"/>.</remarks>
        </member>
        <member name="M:HSS.ObjectSerialization.ToByteArray(System.Object)">
            <summary>
            Serializes an object using a BinaryFormatter.
            </summary>
            <param name="value">The object to serialize to binaryData</param>
            <returns>A byte array containing the binaryData</returns>
            <remarks>Use the <see cref="T:System.Runtime.Serialization.Formatters.Binary.BinaryFormatter"/>.</remarks>
        </member>
        <member name="M:HSS.ObjectSerialization.ToFile(System.Object,System.String)">
            <summary>
            Serializes an object using a BinaryFormatter.
            </summary>
            <param name="value">The object to serialize to binaryData</param>
            <param name="fileName">The file name and path where to write the object</param>
            <remarks>Use the <see cref="T:System.Runtime.Serialization.Formatters.Binary.BinaryFormatter"/>.</remarks>
        </member>
        <member name="M:HSS.ObjectSerialization.ToEncryptedString(System.Object,System.String)">
            <summary>
            Serializes an object using a BinaryFormatter and encrypts the resulting binary data using the provided password.
            </summary>
            <param name="value">The object to serialize.</param>
            <param name="password">The password to encrypt this instance.</param>
            <returns>A BASE64 string.</returns>
        </member>
        <member name="M:HSS.ObjectSerialization.FromBinary(System.String)">
            <summary>
            Gets an instance of an Object from a binaryData File
            </summary>
            <param name="filePath">The path to the binaryData file</param>
            <returns>The Object instance</returns>
        </member>
        <member name="M:HSS.ObjectSerialization.FromBinary(System.IO.FileInfo)">
            <summary>
            Gets an instance of an Object from a binaryData File
            </summary>
            <param name="filePath">The path to the binaryData file</param>
            <returns>The Object instance</returns>
        </member>
        <member name="M:HSS.ObjectSerialization.FromBinary(System.Byte[])">
            <summary>
            Gets an instance of an object from a byte array
            </summary>
            <param name="binaryData">A byte array containing the binaryData</param>
            <returns>The Object Instance</returns>
        </member>
        <member name="M:HSS.ObjectSerialization.FromBinary(System.IO.Stream)">
            <summary>
            Gets an instance of an object from a Stream
            </summary>
            <param name="binaryData">A Stream containing the binaryData</param>
            <returns>The Object Instance</returns>
        </member>
        <member name="M:HSS.ObjectSerialization.FromEncryptedString(System.String,System.String)">
            <summary>
            Decrypts the encrypted string and attempts to deserialize into an object
            instance. The encrypted string must have been created from calling
            <see cref="M:HSS.ObjectSerialization.ToEncryptedString(System.Object,System.String)"/>.
            </summary>
            <param name="encryptedString">The BASE64 string.</param>
            <param name="password">The password to decrypt the <paramref name="encryptedString"/>.</param>
            <returns>A hydrated instance of the object; otherwise null.</returns>
        </member>
        <member name="M:HSS.ObjectSerialization.FromBinary``1(System.String)">
            <summary>
            Gets an instance of an Object from a binaryData File
            </summary>
            <typeparam name="T">The Type of object to deserialize to</typeparam>
            <param name="filePath">The path to the binaryData file</param>
            <returns>The Object instance</returns>
        </member>
        <member name="M:HSS.ObjectSerialization.FromBinary``1(System.IO.FileInfo)">
            <summary>
            Gets an instance of an Object from a binaryData File
            </summary>
            <typeparam name="T">The Type of object to deserialize to</typeparam>
            <param name="filePath">The path to the binaryData file</param>
            <returns>The Object instance</returns>
        </member>
        <member name="M:HSS.ObjectSerialization.FromBinary``1(System.Byte[])">
            <summary>
            Gets an instance of an object from a byte array
            </summary>
            <param name="binaryData">A byte array containing the binaryData</param>
            <returns>The Object Instance</returns>
        </member>
        <member name="M:HSS.ObjectSerialization.FromBinary``1(System.IO.Stream)">
            <summary>
            Gets an instance of an Object from binaryData
            </summary>
            <typeparam name="T">The Type of object to deserialize to</typeparam>
            <param name="binaryData">The binaryData</param>
            <returns>The Object Instance</returns>
        </member>
        <member name="M:HSS.ObjectSerialization.FromEncryptedString``1(System.String,System.String)">
            <summary>
            Decrypts the encrypted string and attempts to deserialize into an object
            instance. The encrypted string must have been created from calling
            <see cref="M:HSS.ObjectSerialization.ToEncryptedString(System.Object,System.String)"/>.
            </summary>
            <param name="encryptedString">The BASE64 string.</param>
            <param name="password">The password to decrypt the <paramref name="encryptedString"/>.</param>
            <returns>A hydrated instance of type T; otherwise null.</returns>
        </member>
        <member name="T:HSS.Security.KeyContainerService">
            <summary>
            Provides functionaity to store and retrieve Key Containers for use with encryption/decryption.
            </summary>
        </member>
        <member name="M:HSS.Security.KeyContainerService.#ctor(System.Boolean,System.Boolean)">
            <summary>
            Default CTOR
            </summary>
            <param name="useMachineStore">Indicate whether or not use the MachineStore versus the UserProfile</param>
            <param name="allowPrompt">Indicate whether or not to allow prompting</param>
            <remarks>
            The values set here are used thru out the objects life time. If you want to switch context, you 
            must create a new instance.
            </remarks>
        </member>
        <member name="M:HSS.Security.KeyContainerService.CreateNew(System.String,System.Int32)">
            <summary>
            Creates a new key container, initializing it with a new RSA encryption key pair.
            </summary>
            <param name="keyName">The name for the key.</param>
            <param name="keySizeInBits">Desired key size in bits.</param>
            <returns>A new RSACryptoServiceProvider</returns>
        </member>
        <member name="M:HSS.Security.KeyContainerService.ImportKey(System.String,System.Byte[])">
            <summary>
            Import from a previously exported Key
            </summary>
            <param name="keyName">The name of the key to set. Must not conflict with an existing key name.</param>
            <param name="blobCsp">The CspBlob that includes the Private information.</param>
        </member>
        <member name="M:HSS.Security.KeyContainerService.LoadKey(System.String)">
            <summary>
            Load a previously saved Key
            </summary>
            <param name="keyName">The name of the key to fetch.</param>
            <returns>The restored RSACryptoServiceProvider</returns>
        </member>
        <member name="M:HSS.Security.KeyContainerService.Delete(System.String)">
            <summary>
            Deletes a saved key
            </summary>
            <param name="keyName">The name of the key to delete.</param>
        </member>
        <member name="M:HSS.Security.KeyContainerService.Exists(System.String)">
            <summary>
            Check to see if a key exists.
            </summary>
            <param name="keyName">The name of the key to check.</param>
            <returns>true if the Key exists; otherwise false</returns>
        </member>
        <member name="M:HSS.Security.KeyContainerService.GetAllKeys">
            <summary>
            Gets a list of all saved keys.
            </summary>
            <returns>A string array contains the names of all the saved keys</returns>
        </member>
        <member name="P:HSS.Security.KeyContainerService.UseMachineStore">
            <summary>
            Gets whether or not to use the MachineStore versus the UserProfile
            </summary>
        </member>
        <member name="P:HSS.Security.KeyContainerService.AllowPrompt">
            <summary>
            Gets whether or not to allow prompting
            </summary>
        </member>
        <member name="T:HSS.Logging.MachineEventLogSource">
            <summary>
            The available Machine EventLog Sources
            </summary>
        </member>
        <member name="F:HSS.Logging.MachineEventLogSource.Configuration">
            <summary>
            A Configuration Subsystem [ 1 ]
            </summary>
        </member>
        <member name="F:HSS.Logging.MachineEventLogSource.Workflow">
            <summary>
            A Workflow Subsystem [ 2 ]
            </summary>
        </member>
        <member name="F:HSS.Logging.MachineEventLogSource.ExternalProcess">
            <summary>
            A surrograte or external process executable [ 3 ]
            </summary>
        </member>
        <member name="F:HSS.Logging.MachineEventLogSource.NTService">
            <summary>
            An NTService [ 4 ]
            </summary>
        </member>
        <member name="F:HSS.Logging.MachineEventLogSource.WebService">
            <summary>
            A Web Service [ 5 ]
            </summary>
        </member>
        <member name="F:HSS.Logging.MachineEventLogSource.WinForm">
            <summary>
            A WinForm Application [ 6 ]
            </summary>
        </member>
        <member name="F:HSS.Logging.MachineEventLogSource.WebForm">
            <summary>
            A WebForm Application [ 7 ]
            </summary>
        </member>
        <member name="F:HSS.Logging.MachineEventLogSource.Installer">
            <summary>
            An Installer [ 8 ]
            </summary>
        </member>
        <member name="F:HSS.Logging.MachineEventLogSource.Debugger">
            <summary>
            A Debugger [ 9 ]
            </summary>
        </member>
        <member name="F:HSS.Logging.MachineEventLogSource.Core">
            <summary>
            Exception from a framework or core library [ 10 ]
            </summary>
        </member>
        <member name="F:HSS.Logging.MachineEventLogSource.General">
            <summary>
            An general log source for non known sources
            </summary>
        </member>
        <member name="F:HSS.Logging.MachineEventLogSource.HSSLogService">
            <summary>
            The HSS Log NTService [ 12 ]
            </summary>
        </member>
        <member name="T:HSS.IO.IconSize">
            <summary>
            Options to specify the size of icons to return.
            </summary>
        </member>
        <member name="F:HSS.IO.IconSize.Large">
            <summary>
            Specify large icon - 32 pixels by 32 pixels.
            </summary>
        </member>
        <member name="F:HSS.IO.IconSize.Small">
            <summary>
            Specify small icon - 16 pixels by 16 pixels.
            </summary>
        </member>
        <member name="T:HSS.IO.FolderType">
            <summary>
            Options to specify whether folders should be in the open or closed state.
            </summary>
        </member>
        <member name="F:HSS.IO.FolderType.Open">
            <summary>
            Specify open folder.
            </summary>
        </member>
        <member name="F:HSS.IO.FolderType.Closed">
            <summary>
            Specify closed folder.
            </summary>
        </member>
        <member name="T:HSS.IO.IconExtractor">
            <summary>
            Provides methods to extract system icons for both folders and files
            </summary>
        </member>
        <member name="M:HSS.IO.IconExtractor.GetFileIcon(System.String,HSS.IO.IconSize,System.Boolean)">
            <summary>
            Returns an icon for a given file - indicated by the name parameter
            </summary>
            <param name="name">Pathname for file.</param>
            <param name="size">Large or small</param>
            <param name="linkOverlay">Whether to include the link overlay icon</param>
            <returns>System.Drawing.Icon</returns>
        </member>
        <member name="M:HSS.IO.IconExtractor.GetFolderIcon(HSS.IO.IconSize,HSS.IO.FolderType)">
            <summary>
            Used to access system folder icons
            </summary>
            <param name="size">Specify large or small icons.</param>
            <param name="folderType">Specify open or closed FolderType.</param>
            <returns>System.Drawing.Icon</returns>
        </member>
        <member name="T:HSS.IO.Shell32">
            <summary>
            Wraps necessary Shell32.dll structures and functions required to retrieve Icon Handles using SHGetFileInfo. Code
            courtesy of MSDN Cold Rooster Consulting case study.
            </summary>
        </member>
        <member name="T:HSS.IO.User32">
            <summary>
            Wraps necessary functions imported from User32.dll. Code courtesy of MSDN Cold Rooster Consulting example.
            </summary>
        </member>
        <member name="M:HSS.IO.User32.DestroyIcon(System.IntPtr)">
            <summary>
            Provides access to function required to delete handle. This method is used internally
            and is not required to be called separately.
            </summary>
            <param name="hIcon">Pointer to icon handle.</param>
            <returns>N/A</returns>
        </member>
        <member name="T:HSS.Logging.LogEntry">
            <summary>
            A Log Entry
            </summary>
        </member>
        <member name="M:HSS.Logging.LogEntry.#ctor">
            <summary>
            Default ctor
            </summary>
        </member>
        <member name="M:HSS.Logging.LogEntry.#ctor(System.String,System.String,System.String,System.String,System.String,System.String,System.DateTime,System.Diagnostics.EventLogEntryType)">
            <summary>
            Constructs a log entry
            </summary>
            <param name="message">The message to write.</param>
            <param name="userName">The name of the person or program writing this message.</param>
            <param name="category">The Category of this entry.</param>
            <param name="xmlString">The Xml String to attach to this entry.</param>
            <param name="applicationName">The name of the application this entry is associated with.</param>
            <param name="referenceNumber">A reference number to associate with the entry.</param>
            <param name="createdDate">The date and time of the entry.</param>
            <param name="eventType">The event type for the entry.</param>
        </member>
        <member name="M:HSS.Logging.LogEntry.#ctor(System.String,System.String,System.String,System.String,System.String,System.DateTime,System.Diagnostics.EventLogEntryType)">
            <summary>
            Constructs a log entry
            </summary>
            <param name="userName">The name of the person or program writing this message.</param>
            <param name="category">The Category of this entry.</param>
            <param name="xmlString">The Xml String to attach to this entry.</param>
            <param name="applicationName">The name of the application this entry is associated with.</param>
            <param name="referenceNumber">A reference number to associate with the entry.</param>
            <param name="createdDate">The date and time of the entry.</param>
            <param name="eventType">The event type for the entry.</param>
        </member>
        <member name="M:HSS.Logging.LogEntry.#ctor(System.Int32,System.String,System.String,System.String,System.String,System.String,System.String,System.DateTime,System.Diagnostics.EventLogEntryType)">
            <summary>
            Constructs a log entry
            </summary>
            <param name="eventId">Id of this Entry</param>
            <param name="message">The message to write.</param>
            <param name="userName">The name of the person or program writing this message.</param>
            <param name="category">The Category of this entry.</param>
            <param name="xmlString">The Xml String to attach to this entry.</param>
            <param name="applicationName">The name of the application this entry is associated with.</param>
            <param name="referenceNumber">A reference number to associate with the entry.</param>
            <param name="createdDate">The date and time of the entry.</param>
            <param name="eventType">The event type for the entry.</param>
        </member>
        <member name="M:HSS.Logging.LogEntry.Update(System.String,System.String,System.String,System.String,System.String,System.Diagnostics.EventLogEntryType)">
            <summary>
            Update the Entry
            </summary>
            <param name="message">The event message</param>
            <param name="category">The Category of this entry</param>
            <param name="referenceNumber">The Reference Number for an Item being processed associated with this entry</param>
            <param name="userName">The user associated with this entry</param>
            <param name="xmlString">The Xml associated with this entry</param>
            <param name="eventType">The Type of this entry</param>
        </member>
        <member name="M:HSS.Logging.LogEntry.ToString">
            <summary>
            Return the EventId and Message for this instance
            </summary>
            <returns>A string containing the EventId and Message for this instance</returns>
        </member>
        <member name="P:HSS.Logging.LogEntry.EventId">
            <summary>
            Gets or sets the Id of this Entry
            </summary>
        </member>
        <member name="P:HSS.Logging.LogEntry.EventType">
            <summary>
            Gets or sets the Type of this entry
            </summary>			
        </member>
        <member name="P:HSS.Logging.LogEntry.Message">
            <summary>
            Gets or sets the event message
            </summary>
        </member>
        <member name="P:HSS.Logging.LogEntry.Category">
            <summary>
            Gets or sets the Category of this entry
            </summary>
        </member>
        <member name="P:HSS.Logging.LogEntry.ApplicationName">
            <summary>
            Gets or sets the name of the application that this entry is associated with.
            </summary>
        </member>
        <member name="P:HSS.Logging.LogEntry.ReferenceNumber">
            <summary>
            Gets or sets the Reference Number for an Item being processed associated with this entry
            </summary>
        </member>
        <member name="P:HSS.Logging.LogEntry.XmlString">
            <summary>
            Gets or sets the Xml associated with this entry
            </summary>
        </member>
        <member name="P:HSS.Logging.LogEntry.User">
            <summary>
            Gets or sets the user associated with this entry
            </summary>
        </member>
        <member name="P:HSS.Logging.LogEntry.CreatedDate">
            <summary>
            Gets or sets the created date.
            </summary>
        </member>
        <member name="P:HSS.Logging.LogEntry.AttachmentId">
            <summary>
            Gets or sets the Id of an associated Attachment
            </summary>
        </member>
        <member name="T:HSS.Guard">
            <summary>
            Guard is an Exception helper for throwing errors if arguments are not valid.
            </summary>
        </member>
        <member name="M:HSS.Guard.ArgumentNotNull(System.Object,System.String)">
            <summary>
            Throws <see cref="T:System.ArgumentNullException"/> if the given argument is null.
            </summary>
            <exception cref="T:System.ArgumentNullException">Thrown if the tested value if null.</exception>
            <param name="argumentValue">Argument value to test.</param>
            <param name="argumentName">Name of the argument being tested.</param>
        </member>
        <member name="M:HSS.Guard.ArgumentNotNullOrEmpty(System.String,System.String)">
            <summary>
            Throws an exception if the tested string argument is null or the empty string.
            </summary>
            <exception cref="T:System.ArgumentNullException">Thrown if the string value is null.</exception>
            <exception cref="T:System.ArgumentException">Thrown if the string is empty</exception>
            <param name="argumentValue">Argument value to check.</param>
            <param name="argumentName">Name of argument being checked.</param>
        </member>
        <member name="M:HSS.Guard.ArgumentIsSerializable(System.Object,System.String)">
            <summary>
            Throws an exception if the tested argument is null or not serializable.
            </summary>
            <exception cref="T:System.ArgumentNullException">Thrown if the tested value if null.</exception>
            <exception cref="T:System.ArgumentException">Thrown if the tested value is not serializable.</exception>
            <param name="argumentValue">Argument value to test.</param>
            <param name="argumentName">Name of the argument being tested.</param>
        </member>
        <member name="M:HSS.Guard.InstanceIsAssignable(System.Type,System.Object,System.String)">
            <summary>
            Verifies that an argument instance is assignable from the provided type (meaning
            interfaces are implemented, or classes exist in the base class hierarchy, or instance can be 
            assigned through a runtime wrapper, as is the case for COM Objects).
            </summary>
            <param name="assignmentTargetType">The argument type that will be assigned to.</param>
            <param name="assignmentInstance">The instance that will be assigned.</param>
            <param name="argumentName">Argument name.</param>
        </member>
        <member name="M:HSS.Guard.TypeIsAssignable(System.Type,System.Type,System.String)">
            <summary>
            Verifies that an argument type is assignable from the provided type (meaning
            interfaces are implemented, or classes exist in the base class hierarchy).
            </summary>
            <param name="assignmentTargetType">The argument type that will be assigned to.</param>
            <param name="assignmentValueType">The type of the value being assigned.</param>
            <param name="argumentName">Argument name.</param>
        </member>
        <member name="T:HSS.CoreException">
            <summary>
            HSS Core exceptions.
            </summary>
        </member>
        <member name="M:HSS.CoreException.#ctor">
            <summary>
            Default Constructor
            </summary>
        </member>
        <member name="M:HSS.CoreException.#ctor(System.String)">
            <summary>
            Default Constructor
            </summary>
            <param name="message">The exception message</param>
        </member>
        <member name="M:HSS.CoreException.#ctor(System.String,System.Exception)">
            <summary>
            Default Constructor
            </summary>
            <param name="message">The exception message</param>
            <param name="innerException">The inner exception</param>
        </member>
        <member name="M:HSS.CoreException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
            <summary>
            Default Constructor
            </summary>
            <param name="info">The SerializationInfo</param>
            <param name="context">The StreamingContext</param>
        </member>
        <member name="T:HSS.Strings">
            <summary>
              A strongly-typed resource class, for looking up localized strings, etc.
            </summary>
        </member>
        <member name="P:HSS.Strings.ResourceManager">
            <summary>
              Returns the cached ResourceManager instance used by this class.
            </summary>
        </member>
        <member name="P:HSS.Strings.Culture">
            <summary>
              Overrides the current thread's CurrentUICulture property for all
              resource lookups using this strongly typed resource class.
            </summary>
        </member>
        <member name="P:HSS.Strings.DocumentNotValid">
             <summary>
               Looks up a localized string similar to There was an error during validation of the Xml.
            
            The validation error was: &apos;{0}&apos;..
             </summary>
        </member>
        <member name="T:HSS.Threading.ScheduleExclusion">
            <summary>
            An Exclusion time spec
            </summary>
        </member>
        <member name="M:HSS.Threading.ScheduleExclusion.#ctor">
            <summary>
            ctor
            </summary>
        </member>
        <member name="P:HSS.Threading.ScheduleExclusion.Day">
            <summary>
            The day of the exclusion
            </summary>
        </member>
        <member name="P:HSS.Threading.ScheduleExclusion.AllDay">
            <summary>
            Indicates the ScheduleExclusion is for the entire day (from 12:00:00 AM to 11:59:59 PM)
            </summary>
        </member>
        <member name="P:HSS.Threading.ScheduleExclusion.StartTime">
            <summary>
            The begin time of the exclusion
            </summary>
        </member>
        <member name="P:HSS.Threading.ScheduleExclusion.EndTime">
            <summary>
            The end time of the exclusion
            </summary>
        </member>
        <member name="T:HSS.Threading.Timer">
            <summary>
            The Timer object is a Threaded Ticker, and supports complex Schedules such
            as once a week between the hours of 8:00 AM and 5:00 PM, or every day at
            6:00 AM, or every other week/month, or on Mondays and Tuesdays 24X7. The
            other key feature is the option to recur within the day such as, repeat
            every 15 minutes or fire continously, such as an open loop. Even though
            there is a forced minimum delay of 550 milliseconds, you can override
            the delay by calling the <c>SetDelay</c> method.
            </summary>
        </member>
        <member name="M:HSS.Threading.Timer.#ctor(HSS.Threading.ITimerService,HSS.Threading.TimerSchedule)">
            <summary>
            The constructor for the Timer
            </summary>
            <param name="service">The TimerService that owns this Timer</param>
            <param name="schedule">The Schedule used for the Timer</param>
        </member>
        <member name="M:HSS.Threading.Timer.Dispose">
            <summary>
            Clean up external resources
            </summary>
        </member>
        <member name="M:HSS.Threading.Timer.Dispose(System.Boolean)">
            <summary>
            Release Unmanaged Resources
            </summary>
            <param name="Disposing">Are we closing</param>
        </member>
        <member name="M:HSS.Threading.Timer.Start">
            <summary>
            Start the timer
            </summary>
            <exception cref="T:System.InvalidOperationException">Cannot submit a start request when not in a stopped or paused state.</exception>
            <exception cref="T:System.ObjectDisposedException">The instance of the Timer is disposed</exception>
        </member>
        <member name="M:HSS.Threading.Timer.Stop">
            <summary>
            Stop the Timer
            </summary>
        </member>
        <member name="M:HSS.Threading.Timer.Pause">
            <summary>
            Pause the Timer
            </summary>
        </member>
        <member name="M:HSS.Threading.Timer.Continue">
            <summary>
            Continue the timer
            </summary>
        </member>
        <member name="M:HSS.Threading.Timer.Close">
            <summary>
            Close the Timer
            </summary>
        </member>
        <member name="M:HSS.Threading.Timer.SetDelay(System.Int32)">
            <summary>
            Allows the delay value to be manually set thereby overriding the delay until the next tick. If the current 
            Frequency is not set to Continuous, then this method is ignored and no action is taken
            </summary>
            <remarks>
            This is to allow for a manual (programmatic) override.
            
            NOTE: The delay value will auto reset to continuous (550ms) at next tick and you will have to 
            re-evaluate if you need to call SetDelay again
            </remarks>
            <param name="delay">Delay in Seconds</param>
        </member>
        <member name="P:HSS.Threading.Timer.State">
            <summary>
            Gets or sets the Timer State
            </summary>
        </member>
        <member name="T:HSS.IO.Zip.EncryptionAlgorithm">
            <summary>
            An enum that provides the various encryption algorithms supported by this library.
            </summary>
        </member>
        <member name="F:HSS.IO.Zip.EncryptionAlgorithm.None">
            <summary>
            No encryption at all.
            </summary>
        </member>
        <member name="F:HSS.IO.Zip.EncryptionAlgorithm.PkZipWeak">
            <summary>
            Traditional or Classic pkzip encryption.
            </summary>
        </member>
        <member name="T:HSS.IO.Zip.EntrySource">
            <summary>
            An enum that specifies the source of the ZipEntry. 
            </summary>
        </member>
        <member name="F:HSS.IO.Zip.EntrySource.None">
            <summary>
            Default value.  Invalid on a bonafide ZipEntry.
            </summary>
        </member>
        <member name="F:HSS.IO.Zip.EntrySource.Filesystem">
            <summary>
            Entry was instantiated by Adding an entry from the filesystem.
            </summary>
        </member>
        <member name="F:HSS.IO.Zip.EntrySource.Zipfile">
            <summary>
            Entry was instantiated by reading a zipfile.
            </summary>
        </member>
        <member name="F:HSS.IO.Zip.EntrySource.Stream">
            <summary>
            Entry was instantiated via a stream or string.
            </summary>
        </member>
        <member name="T:HSS.IO.Zip.ZipEntry">
            <summary>
            Represents a single entry in a ZipFile. Typically, applications
            get a ZipEntry by enumerating the entries within a ZipFile,
            or by adding an entry to a ZipFile.  
            </summary>
        </member>
        <member name="M:HSS.IO.Zip.ZipEntry.#ctor">
            <summary>
            Private constructor
            </summary>
        </member>
        <member name="M:HSS.IO.Zip.ZipEntry.Read(System.IO.Stream,System.Text.Encoding)">
            <summary>
            Reads one ZipEntry from the given stream.  If the entry is encrypted, we don't
            actuall decrypt at this point. 
            </summary>
            <param name="s">the stream to read from.</param>
            <param name="defaultEncoding">
            The text encoding to use when reading the ZipEntry, if it is not marked as UTF-8.
            </param>
            <returns>the ZipEntry read from the stream.</returns>
        </member>
        <member name="M:HSS.IO.Zip.ZipEntry.Extract">
             <summary>
             Extract the entry to the filesystem, starting at the current working directory. 
             </summary>
             
             <overloads>
             This method has a bunch of overloads! One of them is sure to be
             the right one for you... If you don't like these, check out the 
             <c>ExtractWithPassword()</c> methods.
             </overloads>
                     
             <seealso cref="P:HSS.IO.Zip.ZipEntry.OverwriteOnExtract"/>
             <seealso cref="M:HSS.IO.Zip.ZipEntry.Extract(System.Boolean)"/>
            
             <remarks>
             <para>
             Existing entries in the filesystem will not be overwritten. If you would like to 
             force the overwrite of existing files, see the <c>OverwriteOnExtract</c> property, 
             or try one of the overloads of the Extract method that accept a boolean flag
             to indicate explicitly whether you want overwrite.
             </para>
             <para>
             See the remarks on the LastModified property, for some details 
             about how the last modified time of the created file is set.
             </para>
             </remarks>
        </member>
        <member name="M:HSS.IO.Zip.ZipEntry.Extract(System.Boolean)">
            <summary>
            Extract the entry to a file in the filesystem, potentially overwriting
            any existing file.
            </summary>
            <remarks>
            <para>
            See the remarks on the LastModified property, for some details 
            about how the last modified time of the created file is set.
            </para>
            </remarks>
            <param name="overwrite">true if the caller wants to overwrite an existing file by the same name in the filesystem.</param>
        </member>
        <member name="M:HSS.IO.Zip.ZipEntry.Extract(System.IO.Stream)">
            <summary>
            Extracts the entry to the specified stream. 
            For example, the caller could specify Console.Out, or a MemoryStream.
            </summary>
            
            <param name="stream">the stream to which the entry should be extracted.  </param>
            
            <remarks>
            <para>
            See the remarks on the LastModified property, for some details 
            about how the last modified time of the created file is set.
            </para>
            </remarks>
        </member>
        <member name="M:HSS.IO.Zip.ZipEntry.Extract(System.String)">
            <summary>
            Extract the entry to the filesystem, starting at the specified base directory. 
            </summary>
            
            <param name="baseDirectory">the pathname of the base directory</param>
            
            <seealso cref="P:HSS.IO.Zip.ZipEntry.OverwriteOnExtract"/>
            <seealso cref="M:HSS.IO.Zip.ZipEntry.Extract(System.String,System.Boolean)"/>
            <seealso cref="M:HSS.IO.Zip.ZipEntry.Extract(System.String)"/>
            
            <example>
            This example extracts only the entries in a zip file that are .txt files, into a directory called "textfiles".
            <code lang="C#">
            using (ZipFile zip = ZipFile.Read("PackedDocuments.zip"))
            {
              foreach (string s1 in zip.EntryFilenames)
              {
                if (s1.EndsWith(".txt")) 
                {
                  ZipEntry entry= zip[s1];
                  entry.Extract("textfiles");
                }
              }
            }
            </code>
            <code lang="VB">
              Using zip As ZipFile = ZipFile.Read("PackedDocuments.zip")
                  Dim s1 As String
                  For Each s1 In zip.EntryFilenames
                      If s1.EndsWith(".txt") Then
                          Dim entry as ZipEntry
                          entry = zip(s1)
                          entry.Extract("textfiles")
                      End If
                  Next
              End Using
            </code>
            </example>
            
            <remarks>
            <para>
            Existing entries in the filesystem will not be overwritten. If you would like to 
            force the overwrite of existing files, see the <c>OverwriteOnExtract</c> property, 
            or try one of the overloads of the Extract method that accept a boolean flag
            to indicate explicitly whether you want overwrite.
            </para>
            <para>
            See the remarks on the LastModified property, for some details 
            about how the last modified time of the created file is set.
            </para>
            </remarks>
        </member>
        <member name="M:HSS.IO.Zip.ZipEntry.Extract(System.String,System.Boolean)">
            <summary>
            Extract the entry to the filesystem, starting at the specified base directory, 
            and potentially overwriting existing files in the filesystem. 
            </summary>
            
            <remarks>
            <para>
            See the remarks on the LastModified property, for some details 
            about how the last modified time of the created file is set.
            </para>
            </remarks>
            
            <param name="baseDirectory">the pathname of the base directory</param>
            <param name="overwrite">If true, overwrite any existing files if necessary upon extraction.</param>
        </member>
        <member name="M:HSS.IO.Zip.ZipEntry.ExtractWithPassword(System.String)">
             <summary>
             Extract the entry to the filesystem, using the current working directory,
             and using the specified password. 
             </summary>
            
             <overloads>
             This method has a bunch of overloads! One of them is sure to be
             the right one for you...
             </overloads>
                     
             <seealso cref="P:HSS.IO.Zip.ZipEntry.OverwriteOnExtract"/>
             <seealso cref="M:HSS.IO.Zip.ZipEntry.ExtractWithPassword(System.Boolean,System.String)"/>
            
             <remarks>
             <para>
             Existing entries in the filesystem will not be overwritten. If you would like to 
             force the overwrite of existing files, see the <c>OverwriteOnExtract</c> property, 
             or try one of the overloads of the ExtractWithPassword method that accept a boolean flag
             to indicate explicitly whether you want overwrite.
             </para>
             <para>
             See the remarks on the LastModified property, for some details 
             about how the last modified time of the created file is set.
             </para>
             </remarks>
            
             <param name="password">The Password to use for decrypting the entry.</param>
        </member>
        <member name="M:HSS.IO.Zip.ZipEntry.ExtractWithPassword(System.String,System.String)">
             <summary>
             Extract the entry to the filesystem, starting at the specified base directory,
             and using the specified password. 
             </summary>
             
             <seealso cref="P:HSS.IO.Zip.ZipEntry.OverwriteOnExtract"/>
             <seealso cref="M:HSS.IO.Zip.ZipEntry.ExtractWithPassword(System.String,System.Boolean,System.String)"/>
            
             <remarks>
             <para>
             Existing entries in the filesystem will not be overwritten. If you would like to 
             force the overwrite of existing files, see the <c>OverwriteOnExtract</c> property, 
             or try one of the overloads of the ExtractWithPassword method that accept a boolean flag
             to indicate explicitly whether you want overwrite.
             </para>
             <para>
             See the remarks on the LastModified property, for some details 
             about how the last modified time of the created file is set.
             </para>
             </remarks>
             
             <param name="baseDirectory">The pathname of the base directory.</param>
             <param name="password">The Password to use for decrypting the entry.</param>
        </member>
        <member name="M:HSS.IO.Zip.ZipEntry.ExtractWithPassword(System.Boolean,System.String)">
            <summary>
            Extract the entry to a file in the filesystem, potentially overwriting
            any existing file.
            </summary>
            
            <remarks>
            <para>
            See the remarks on the LastModified property, for some details 
            about how the last modified time of the created file is set.
            </para>
            </remarks>
            
            <param name="overwrite">true if the caller wants to overwrite an existing 
            file by the same name in the filesystem.</param>
            <param name="password">The Password to use for decrypting the entry.</param>
        </member>
        <member name="M:HSS.IO.Zip.ZipEntry.ExtractWithPassword(System.String,System.Boolean,System.String)">
             <summary>
             Extract the entry to the filesystem, starting at the specified base directory, 
             and potentially overwriting existing files in the filesystem. 
             </summary>
             
             <remarks>
             See the remarks on the LastModified property, for some details 
             about how the last modified time of the created file is set.
             </remarks>
            
             <param name="baseDirectory">the pathname of the base directory</param>
             <param name="overwrite">If true, overwrite any existing files if necessary upon extraction.</param>
             <param name="password">The Password to use for decrypting the entry.</param>
        </member>
        <member name="M:HSS.IO.Zip.ZipEntry.ExtractWithPassword(System.IO.Stream,System.String)">
            <summary>
            Extracts the entry to the specified stream, using the specified Password.
            For example, the caller could extract to Console.Out, or to a MemoryStream.
            </summary>
            
            <remarks>
            See the remarks on the LastModified property, for some details 
            about how the last modified time of the created file is set.
            </remarks>
            
            <param name="stream">the stream to which the entry should be extracted.  </param>
            <param name="password">The password to use for decrypting the entry.</param>
        </member>
        <member name="M:HSS.IO.Zip.ZipEntry.OpenReader">
            <summary>
            Opens the backing stream for the zip entry in the archive, for reading. 
            </summary>
            <remarks>
            <para>
            The ZipEntry has methods that extract the entry to an already-opened stream.
            This is an alternative method for those applications that wish to manipulate the stream directly.
            </para>
            <para>
            The CrcCalculatorStream that is returned is just a regular read-only stream - you can use it as you would
            any stream.  The one additional feature it adds is that it calculates a CRC32 on the bytes of the stream 
            as it is read.  This CRC should be used by the application to validate the content of the ZipEntry, when 
            the read is complete.  Check the example for how to do this. 
            </para>
            <para>
            If the entry is protected with a password, then you need to set the password on the entry prior to calling OpenReader().
            </para>
            </remarks>
            <example>
            In this example, we open a zipfile, then read in a named entry via a stream, scanning
            the bytes in the entry as we go.  Finally, the CRC and the size of the entry are verified.
            <code>
            using (ZipFile zip = new ZipFile(ZipFileToRead))
            {
              ZipEntry e1= zip["Download.mp3"];
              using (CrcCalculatorStream s = e1.OpenReader())
              {
                byte[] buffer = new byte[4096];
                int n, totalBytesRead= 0;
                do {
                  n = s.Read(buffer,0, buffer.Length);
                  totalBytesRead+=n; 
                } while (n&gt;0);
                 if (s.Crc32 != e1.Crc32)
                  throw new Exception(string.Format("The Zip Entry failed the CRC Check. (0x{0:X8}!=0x{1:X8})", s.Crc32, e1.Crc32));
                 if (totalBytesRead != e1.UncompressedSize)
                  throw new Exception(string.Format("We read an unexpected number of bytes. ({0}!={1})", totalBytesRead, e1.UncompressedSize));
              }
            }
            </code>
            <code lang="VB">
              Using zip As New ZipFile(ZipFileToRead)
                  Dim e1 As ZipEntry = zip.Item("Download.mp3")
                  Using s As CrcCalculatorStream = e1.OpenReader
                      Dim n As Integer
                      Dim buffer As Byte() = New Byte(4096) {}
                      Dim totalBytesRead As Integer = 0
                      Do
                          n = s.Read(buffer, 0, buffer.Length)
                          totalBytesRead = (totalBytesRead + n)
                      Loop While (n &gt; 0)
                      If (s.Crc32 &lt;&gt; e1.Crc32) Then
                          Throw New Exception(String.Format("The Zip Entry failed the CRC Check. (0x{0:X8}!=0x{1:X8})", s.Crc32, e1.Crc32))
                      End If
                      If (totalBytesRead &lt;&gt; e1.UncompressedSize) Then
                          Throw New Exception(String.Format("We read an unexpected number of bytes. ({0}!={1})", totalBytesRead, e1.UncompressedSize))
                      End If
                  End Using
              End Using
            </code>
            </example>
            <seealso cref="M:HSS.IO.Zip.ZipEntry.Extract(System.IO.Stream)"/>
            <returns>The Stream for reading.</returns>
        </member>
        <member name="M:HSS.IO.Zip.ZipEntry.OpenReader(System.String)">
            <summary>
            Opens the backing stream for an encrypted zip entry in the archive, for reading. 
            </summary>
            <remarks>
            <para>
            See the documentation on the OpenReader() method for full details.  This overload allows the 
            application to specify a password for the ZipEntry to be read. 
            </para>
            </remarks>
            <param name="password">The password to use for decrypting the entry.</param>
            <returns>The Stream for reading.</returns>
        </member>
        <member name="P:HSS.IO.Zip.ZipEntry.LastModified">
             <summary>
             The time and date at which the file indicated by the ZipEntry was last modified. 
             </summary>
             
             <remarks>
             <para>
             The Zip library sets the LastModified value for an entry, equal to the 
             Last Modified time of the file in the filesystem.  If an entry is added from a stream, 
             in which case no Last Modified attribute is available, the library uses 
             <c>System.DateTime.Now</c> for this value, for the given entry. 
             </para>
            
             <para>
             It is also possible to set the LastModified value on an entry, to an arbitrary
             value.  Be aware that because of the way the PKZip specification describes how
             times are stored in the zip file, the full precision of the
             <c>System.DateTime</c> datatype is not stored in LastModified when saving zip
             files.  For more information on how times are formatted, see the PKZip
             specification.
             </para>
            
             <para>
             The last modified time of the file created upon a call to <c>ZipEntry.Extract()</c> 
             may be adjusted during extraction to compensate
             for differences in how the .NET Base Class Library deals
             with daylight saving time (DST) versus how the Windows
             filesystem deals with daylight saving time. 
             See http://blogs.msdn.com/oldnewthing/archive/2003/10/24/55413.aspx for more context.
             </para>
             <para>
             In a nutshell: Daylight savings time rules change regularly.  In
             2007, for example, the inception week of DST changed.  In 1977,
             DST was in place all year round. In 1945, likewise.  And so on.
             Win32 does not attempt to guess which time zone rules were in
             effect at the time in question.  It will render a time as
             "standard time" and allow the app to change to DST as necessary.
              .NET makes a different choice.
             </para>
             <para>
             Compare the output of FileInfo.LastWriteTime.ToString("f") with
             what you see in the property sheet for a file that was last
             written to on the other side of the DST transition. For example,
             suppose the file was last modified on October 17, 2003, during DST but
             DST is not currently in effect. Explorer's file properties
             reports Thursday, October 17, 2003, 8:45:38 AM, but .NETs
             FileInfo reports Thursday, October 17, 2003, 9:45 AM.
             </para>
             <para>
             Win32 says, "Thursday, October 17, 2002 8:45:38 AM PST". Note:
             Pacific STANDARD Time. Even though October 17 of that year
             occurred during Pacific Daylight Time, Win32 displays the time as
             standard time because that's what time it is NOW.
             </para>
             <para>
             .NET BCL assumes that the current DST rules were in place at the
             time in question.  So, .NET says, "Well, if the rules in effect
             now were also in effect on October 17, 2003, then that would be
             daylight time" so it displays "Thursday, October 17, 2003, 9:45
             AM PDT" - daylight time.
             </para>
             <para>
             So .NET gives a value which is more intuitively correct, but is
             also potentially incorrect, and which is not invertible. Win32
             gives a value which is intuitively incorrect, but is strictly
             correct.
             </para>
             <para>
             Because of this funkiness, this library adds one hour to the LastModified time
             on the extracted file, if necessary.  That is to say, if the time in question
             had occurred in what the .NET Base Class Library assumed to be DST (an
             assumption that may be wrong given the constantly changing DST rules).
             </para>
             </remarks>
            
        </member>
        <member name="P:HSS.IO.Zip.ZipEntry.TrimVolumeFromFullyQualifiedPaths">
            <summary>
            When this is set, this class trims the volume (eg C:\) from any
            fully-qualified pathname on the ZipEntry, before writing the ZipEntry into
            the ZipFile. This flag affects only zip creation. By default, this flag is TRUE,
            which means volume names will not be included in the filenames on entries in
            the archive.  Your best bet is to just leave this alone.
            </summary>
        </member>
        <member name="P:HSS.IO.Zip.ZipEntry.ForceNoCompression">
            <summary>
            When this is set, the entry is not compressed when written to 
            the archive.  For example, the application might want to set flag to True
            this when zipping up JPG or MP3 files, which are already compressed.
            </summary>
        </member>
        <member name="P:HSS.IO.Zip.ZipEntry.LocalFileName">
            <summary>
            The name of the filesystem file, referred to by the ZipEntry. 
            </summary>
            
            <remarks>
            <para>
            This may be different than the path used in the archive itself. What I mean is, 
            if you call Zip.AddFile("fooo.txt"", AlternativeDirectory), then the 
            path used in the zip entry will be different than this path.  This path is 
            used to locate the thing-to-be-zipped on disk. 
            </para>
            <para>
            If the entry is being added from a stream, then this is null (Nothing in VB).
            </para>
            
            </remarks>
            <seealso cref="P:HSS.IO.Zip.ZipEntry.FileName"/>
        </member>
        <member name="P:HSS.IO.Zip.ZipEntry.FileName">
             <summary>
             The name of the file contained in the ZipEntry. 
             </summary>
             
             <remarks>
             <para>
             When writing a zip, this path has backslashes replaced with 
             forward slashes, according to the zip spec, for compatibility
             with Unix(tm) and ... get this.... Amiga!
             </para>
            
             <para>
             This is the name of the entry in the ZipFile itself.  This name may be different
             than the name of the filesystem file used to create the entry. In fact, there
             may be no filesystem file at all, if the entry is created from a stream or a string.
             </para>
             </remarks>
             <seealso cref="P:HSS.IO.Zip.ZipEntry.LocalFileName"/>
        </member>
        <member name="P:HSS.IO.Zip.ZipEntry.VersionNeeded">
            <summary>
            The version of the zip engine needed to read the ZipEntry.  This is usually 0x14. 
            (Decimal 20).
            </summary>
        </member>
        <member name="P:HSS.IO.Zip.ZipEntry.Comment">
            <summary>
            The comment attached to the ZipEntry. 
            </summary>
        </member>
        <member name="P:HSS.IO.Zip.ZipEntry.BitField">
             <summary>
             The bitfield as defined in the zip spec. In the current implementation, the
             only thing this library potentially writes to the general purpose
             Bitfield is an encryption indicators.
             </summary>
             <code>
             bit  0 - set if encryption is used.
             b. 1-2 - set to determine whether normal, max, fast deflation.  
                      This library always leaves these bits unset when writing (indicating 
                      "normal" deflation").
            
             bit  3 - indicates crc32, compressed and uncompressed sizes are zero in
                      local header.  We always leave this as zero on writing, but can read
                      a zip with it nonzero. 
            
             bit  4 - reserved for "enhanced deflating". This library doesn't do enhanced deflating.
             bit  5 - set to indicate the zip is compressed patched data.  This library doesn't do that.
             bit  6 - set if strong encryption is used (must also set bit 1 if bit 6 is set)
             bit  7 - unused
             bit  8 - unused
             bit  9 - unused
             bit 10 - unused
             Bit 11 - Language encoding flag (EFS).  If this bit is set,
                      the filename and comment fields for this file
                      must be encoded using UTF-8. This library currently does not support UTF-8.
             Bit 12 - Reserved by PKWARE for enhanced compression.
             Bit 13 - Used when encrypting the Central Directory to indicate 
                      selected data values in the Local Header are masked to
                      hide their actual values.  See the section describing 
                      the Strong Encryption Specification for details.
             Bit 14 - Reserved by PKWARE.
             Bit 15 - Reserved by PKWARE.
             </code>
        </member>
        <member name="P:HSS.IO.Zip.ZipEntry.CompressionMethod">
            <summary>
            The compression method employed for this ZipEntry. 0x08 = Deflate.  0x00 =
            Store (no compression).  Really, this should be an enum.  But the zip spec
            makes it a byte. So here it is. 
            </summary>
            
            <remarks>
            <para>When reading an entry from an existing zipfile, the value you retrieve here
            indicates the compression method used on the entry by the original creator of the zip.  
            When writing a zipfile, you can specify either 0x08 (Deflate) or 0x00 (None).  If you 
            try setting something else, it will throw an exception.  
            </para>
            <para>
            You may wish to set CompressionMethod to 0 (None) when zipping previously compressed
            data like jpg, png, or mp3 files.  This can save time and cpu cycles.
            </para>
            </remarks>
            
            <example>
            In this example, the first entry added to the zip archive uses 
            the default behavior - compression is used where it makes sense.  
            The second entry, the MP3 file, is added to the archive without being compressed.
            <code>
            using (ZipFile zip = new ZipFile(ZipFileToCreate))
            {
              ZipEntry e1= zip.AddFile(@"c:\temp\Readme.txt");
              ZipEntry e2= zip.AddFile(@"c:\temp\StopThisTrain.mp3");
              e2.CompressionMethod = 0;
              zip.Save();
            }
            </code>
            
            <code lang="VB">
            Using zip as new ZipFile(ZipFileToCreate)
              zip.AddFile("c:\temp\Readme.txt")
              Dim e2 as ZipEntry = zip.AddFile("c:\temp\StopThisTrain.mp3")
              e2.CompressionMethod = 0
              zip.Save
            End Using
            </code>
            </example>
        </member>
        <member name="P:HSS.IO.Zip.ZipEntry.CompressedSize">
            <summary>
            The compressed size of the file, in bytes, within the zip archive. 
            </summary>
            <remarks>
            The compressed size is computed during compression. This means that it is only
            valid to read this AFTER reading in an existing zip file, or AFTER saving a
            zipfile you are creating.
            </remarks>
        </member>
        <member name="P:HSS.IO.Zip.ZipEntry.UncompressedSize">
            <summary>
            The size of the file, in bytes, before compression, or after extraction. 
            </summary>
        </member>
        <member name="P:HSS.IO.Zip.ZipEntry.CompressionRatio">
            <summary>
            The ratio of compressed size to uncompressed size. This is a double in the
            range of 0 to 100.  You could print it with a format string of "{3,5:F0}%"
            to see it as a percentage. If the size of the original uncompressed file is 0, 
            the return value will be zero. 
            </summary>
        </member>
        <member name="P:HSS.IO.Zip.ZipEntry.Crc32">
            <summary>
            The CRC (Cyclic Redundancy Check) on the contents of the ZipEntry.
            </summary>
        </member>
        <member name="P:HSS.IO.Zip.ZipEntry.IsDirectory">
            <summary>
            True if the entry is a directory (not a file). 
            This is a readonly property on the entry.
            </summary>
        </member>
        <member name="P:HSS.IO.Zip.ZipEntry.UsesEncryption">
            <summary>
            A derived property that is True if the entry uses encryption.  
            This is a readonly property on the entry.
            Upon reading an entry, this bool is determined by
            the data read.  When writing an entry, this bool is
            determined by whether the Encryption property is set to something other than
            EncryptionAlgorithm.None. 
            </summary>
        </member>
        <member name="P:HSS.IO.Zip.ZipEntry.Encryption">
            <summary>
            Set this to specify which encryption algorithm to use for the entry.
            In order for this to succeed, you must also set a Password on the entry.
            The set of algoritms is determined by the PKZIP specification from PKWare.
            The "traditional" encryption used by PKZIP is considered weak.  PKZip also
            supports strong encryption mechanisms including AES of various keysizes and
            Blowfish, among others.  This library does not implement the full PKZip
            spec. 
            </summary>
        </member>
        <member name="P:HSS.IO.Zip.ZipEntry.Password">
            <summary>
            Set this to request that the entry be encrypted when writing the zip
            archive.  This is a write-only property on the entry. The password 
            is used to encrypt the entry during the Save() operation, or decrypt during
            the Extract() or OpenReader() operation. 
            </summary>
        </member>
        <member name="P:HSS.IO.Zip.ZipEntry.OverwriteOnExtract">
            <summary>
            Specifies that the extraction should overwrite any existing files.
            This applies only when calling an Extract method. By default this 
            property is false. 
            </summary>
        </member>
        <member name="P:HSS.IO.Zip.ZipEntry.WillReadTwiceOnInflation">
             <summary>
             A callback that allows the application to specify whether multiple reads of the
             stream should be performed, in the case that a compression operation actually
             inflates the size of the file data.  
             </summary>
            
             <remarks>
             <para>
             In some cases, applying the Deflate compression algorithm in DeflateStream can
             result an increase in the size of the data.  This "inflation" can happen with
             previously compressed files, such as a zip, jpg, png, mp3, and so on.  In a few
             tests, inflation on zip files can be as large as 60%!  Inflation can also happen
             with very small files.  In these cases, by default, the library
             discards the compressed bytes, and stores the uncompressed file data into the
             zip archive.  This is an optimization where smaller size is preferred over
             longer run times.
             </para>
            
             <para>
             The application can specify that compression is not even tried, by setting the
             ForceNoCompression flag.  In this case, the compress-and-check-sizes process as
             decribed above, is not done.
             </para>
            
             <para>
             In some cases, neither choice is optimal.  The application wants compression,
             but in some cases also wants to avoid reading the stream more than once.  This
             may happen when the stream is very large, or when the read is very expensive, or
             when the difference between the compressed and uncompressed sizes is not
             significant.
             </para>
            
             <para>
             To satisfy these applications, this delegate allows the library to ask
             the application to for approval for re-reading the stream.  As with other
             properties (like Password and ForceNoCompression), setting the corresponding
             delegate on the ZipFile class itself will set it on all ZipEntry items that are
             subsequently added to the ZipFile instance.
             </para>
            
             </remarks>
             <seealso cref="P:HSS.IO.Zip.ZipEntry.WillReadTwiceOnInflation"/>
             <seealso cref="T:HSS.IO.Zip.RereadApprovalCallback"/>
        </member>
        <member name="P:HSS.IO.Zip.ZipEntry.WantCompression">
             <summary>
             A callback that allows the application to specify whether compression should
             be used for a given entry that is about to be added to the zip archive.
             </summary>
            
             <remarks>
             <para>
             In some cases, applying the Deflate compression algorithm to an entry can
             result an increase in the size of the data.  This "inflation" can happen with
             previously compressed files, such as a zip, jpg, png, mp3, and so on.  In a few
             tests, inflation on zip files can be as large as 60%!  Inflation can also happen
             with very small files.  
             </para>
            
             <para>
             To handle these cases, the library takes this approach: first it
             applies a heuristic, to determine whether it should try to compress a file or
             not.  The library checks the extension of the entry, and if it is one of a
             known list of uncompressible file types (mp3, zip, docx, and others), the
             library will not attempt to compress the entry.  The library does not actually
             check the content of the entry.  If you name a text file "Text.zip", and then
             attempt to add it to a zip archive, this library will, by default, not attempt
             to compress the entry.
             </para>
            
             <para>
             For filetypes not covered by that heuristic, the library attempts to compress
             the entry, and then checks the size of the result.  If applying the Deflate
             algorithm increases the size of the data, then the library discards the
             compressed bytes, and stores the uncompressed file data into the zip archive,
             in compliance with the zip spec.  This is an optimization where smaller size is
             preferred over longer run times.
             </para>
            
             <para>
             Next, the library exposes this callback.  With
             this callback, the application can supply its own logic for determining whether
             to apply the Deflate algorithm or not.  For example, an application may desire
             that files over 40mb in size are never compressed, or always compressed.  An
             application may desire that the first 7 entries added to an archive are
             compressed, and the remaining ones are not.  The WantCompression callback
             allows the application full control, on an entry-by-entry basis.
             </para>
            
             <para>
             Finally, the application can specify that compression is not even tried, by setting the
             ForceNoCompression flag.  In this case, the compress-and-check-sizes process as
             decribed above, is not done, nor is the callback invoked.
             </para>
             </remarks>
        </member>
        <member name="P:HSS.IO.Zip.ZipEntry.UseUtf8Encoding">
            <summary>
            Set to indicate whether to use UTF-8 encoding on filenames and 
            comments, according to the PKWare specification.  
            </summary>
            <remarks>
            If this flag is set, the entry will be marked as encoded with UTF-8, 
            according to the PWare spec, if necessary.  Necessary means, if there are non-ANSI 
            characters in the filename or in the comment attached to the entry.  
            The default is to use IBM437 encoding. 
            </remarks>
            <remarks>
            Setting this flag to true is equivalent to setting <c>Encoding</c> to <c>System.Text.Encoding.GetEncoding("UTF-8")</c>
            </remarks>
        </member>
        <member name="P:HSS.IO.Zip.ZipEntry.Encoding">
            <summary>
            The text encoding to use for this ZipEntry.  
            </summary>
            <remarks>
            <para>
            In its AppNote.txt document, PKWare describes how to specify in the zip entry header
            that a filename or comment containing non-ANSI characters is encoded with UTF-8.  But, some 
            archivers do not follow the specification, and instead encode super-ANSI characters using the 
            system default code page.  For example, WinRAR when run on a machine in Shanghai may encode 
            filenames with the Chinese code page.  This behavior is contrary to the Zip specification, but it 
            occurs anyway.
            </para>
            <para>
            When writing zip archives that will be read by one of these other archivers, use this property to 
            specify the code page to use when encoding filenames and comments into the zip file.
            </para>
            <para>
            Be aware that a zip file created after you've explicitly specified the code page will not 
            be compliant to the PKWare specification, and may not be readable by compliant archivers. 
            On the other hand, many archivers are non-compliant and can read zip files created in 
            arbitrary code pages. 
            </para>
            <para>
            When using an arbitrary, non-UTF8 code page for encoding, there is no standard way for the 
            creator to specify in the zip file which code page has been used. This Zip library is not
            able to inspect the zip file and determine the codepage used for the entries within it. Therefore, 
            you, the application author, must determine that.  If you use a codepage which results in filenames
            that are not legal in Windows, you will get exceptions upon extract. Caveat Emptor.
            </para>
            </remarks>
        </member>
        <member name="T:HSS.IO.Zip.SharedUtilities">
            <summary>
            Collects general purpose utility methods.
            </summary>
        </member>
        <member name="M:HSS.IO.Zip.SharedUtilities.#ctor">
            <summary>
            Constructor
            </summary>
        </member>
        <member name="M:HSS.IO.Zip.SharedUtilities.RoundToEvenSecond(System.DateTime)">
             <summary>
             Round the given DateTime value to an even second value.  
             </summary>
            
             <remarks>
             <para>
             Round up in the case of an odd second value.  The rounding does not consider fractional seconds.
             </para>
             <para>
             This is useful because the Zip spec allows storage of time only to the nearest even second.
             So if you want to compare the time of an entry in the archive with it's actual time in the filesystem, you 
             need to round the actual filesystem time, or use a 2-second threshold for the  comparison. 
             </para>
             <para>
             This is most nautrally an extension method for the DateTime class but this library is 
             built for .NET 2.0, not for .NET 3.5;  This means extension methods are a no-no.  
             </para>
             </remarks>
             <param name="source">The DateTime value to round</param>
             <returns>The ruonded DateTime value</returns>
        </member>
        <member name="M:HSS.IO.Zip.SharedUtilities.TrimVolumeAndSwapSlashes(System.String)">
            <summary>
            Utility routine for transforming path names. 
            </summary>
            <param name="pathName">source path.</param>
            <returns>transformed path</returns>
        </member>
        <member name="M:HSS.IO.Zip.SharedUtilities.StringToMemoryStream(System.String)">
            <summary>
            Creates a <c>MemoryStream</c> for the given string. This is used internally by Library, specifically by 
            the ZipFile.AddStringAsFile() method.   But it may be useful in other scenarios. 
            </summary>
            <param name="s">The string to use as input for the MemoryStream</param>
            <returns>the MemoryStream. Reading the stream will give you the content of the String.</returns>
        </member>
        <member name="M:HSS.IO.Zip.SharedUtilities.FindSignature(System.IO.Stream,System.Int32)">
            <summary>
            Finds a signature in the zip stream. This is useful for finding 
            the end of a zip entry, for example. 
            </summary>
            <param name="stream"></param>
            <param name="SignatureToFind"></param>
            <returns></returns>
        </member>
        <member name="T:HSS.IO.Zip.CountingStream">
            <summary> 
            A Stream wrapper, used for bookkeeping on input or output
            streams.  In some cases, it is not possible to get the Position
            of a stream, let's say, on a write-only output stream like
            ASP.NET's Response.Output, or on a different write-only stream
            provided as the destination for the zip by the application.
            In this case, we can use this counting stream to count the bytes
            read or written.
            </summary>
        </member>
        <member name="M:HSS.IO.Zip.CountingStream.#ctor(System.IO.Stream)">
            <summary>
            Constructor
            </summary>
            <param name="s">The underlying stream</param>
        </member>
        <member name="T:HSS.Security.Cryptography.Certificates.TrustAllSslPolicy">
            <summary>
            Trusts all Certificates where the port is 443. Should be used with caution!
            </summary>
        </member>
        <member name="M:HSS.Security.Cryptography.Certificates.TrustAllSslPolicy.CheckValidationResult(System.Net.ServicePoint,System.Security.Cryptography.X509Certificates.X509Certificate,System.Net.WebRequest,System.Int32)">
            <summary>
            Allows trusts for all certificates where the port is 443. USE WITH CAUTION!
            </summary>
            <param name="srvPoint">The System.Net.ServicePoint that will use the certificate.</param>
            <param name="certificate">The certificate to validate.</param>
            <param name="request">The request that received the certificate.</param>
            <param name="certificateProblem">The problem that was encountered when using the certificate.</param>
            <returns>true if the certificate should be honored; otherwise, false.</returns>
        </member>
        <member name="T:HSS.IO.Zip.ZipCrypto">
            <summary> 
            This class implements the "traditional" or "classic" PKZip encryption,
            which today is considered to be weak. On the other hand it is
            ubiquitous. This class is intended for use only by the this Zip library.
            </summary>
            <remarks>
            Most uses of the this library will not involve direct calls into the
            ZipCrypto class.  Instead, the ZipCrypto class is instantiated and used by
            the ZipEntry() class when encryption or decryption on an entry is employed.
            If for some reason you really wanted to use a weak encryption algorithm
            in some other application, you might use this library.  But you would be much
            better off using one of the built-in strong encryption libraries in the 
            .NET Framework, like the AES algorithm or SHA. 
            </remarks>
        </member>
        <member name="M:HSS.IO.Zip.ZipCrypto.#ctor">
            <summary>
            The default constructor.  You're probably never gonna call this.  Seriously.
            Stop reading this documentation.  It's not useful to you.  Go do something else.
            Check the football scores. Go get an ice cream with a friend.  Seriously.
            </summary>
        </member>
        <member name="M:HSS.IO.Zip.ZipCrypto.DecryptMessage(System.Byte[],System.Int32)">
            <summary> 
            Call this method on a cipher text to render the plaintext. You must
            first initialize the cipher with a call to InitCipher.
            </summary>		
            <example>
            <code>
            var cipher = new ZipCrypto();
            cipher.InitCipher(Password);
            // Decrypt the header.  This has a side effect of "further initializing the
            // encryption keys" in the traditional zip encryption. 
            byte[] DecryptedMessage = cipher.DecryptMessage(EncryptedMessage);
            </code>
            </example>
            <param name="cipherText">The encrypted buffer.</param>
            <param name="length">
            The number of bytes to encrypt.  
            Should be less than or equal to CipherText.Length.
            </param>
            <returns>The plaintext.</returns>
        </member>
        <member name="M:HSS.IO.Zip.ZipCrypto.EncryptMessage(System.Byte[],System.Int32)">
            <summary>
            This is the converse of DecryptMessage.  It encrypts the plaintext
            and produces a ciphertext. 
            </summary>
            <param name="plaintext">The plain text buffer.</param>
            <param name="length">
            The number of bytes to encrypt.  
            Should be less than or equal to PlainText.Length.
            </param>
            <returns>The ciphertext.</returns>
        </member>
        <member name="M:HSS.IO.Zip.ZipCrypto.InitCipher(System.String)">
             <summary>
             This initializes the cipher with the given password. 
             See AppNote.txt for details. 
             </summary>
             <param name="passphrase">The passphrase for encrypting or decrypting with this cipher.
             </param>
             <remarks>
             <code>
             Step 1 - Initializing the encryption keys
             -----------------------------------------
             Start with these keys:        
             Key(0) := 305419896 (0x12345678)
             Key(1) := 591751049 (0x23456789)
             Key(2) := 878082192 (0x34567890)
             
             Then, initialize the keys with a password:
             
             loop for i from 0 to length(password)-1
                 update_keys(password(i))
             end loop
             
             Where update_keys() is defined as:
             
             update_keys(char):
               Key(0) := crc32(key(0),char)
               Key(1) := Key(1) + (Key(0) bitwiseAND 000000ffH)
               Key(1) := Key(1) * 134775813 + 1
               Key(2) := crc32(key(2),key(1) rightshift 24)
             end update_keys
             
             Where crc32(old_crc,char) is a routine that given a CRC value and a
             character, returns an updated CRC value after applying the CRC-32
             algorithm described elsewhere in this document.
            
             </code>
             <para>
             After the keys are initialized, then you can use the cipher to encrypt
             the plaintext. 
             </para>
             <para>
             Essentially we encrypt the password with the keys, then discard the 
             ciphertext for the password. This initializes the keys for later use.
             </para>
             </remarks>
        </member>
        <member name="M:HSS.IO.Zip.ZipCrypto.UpdateKeys(System.Byte)">
            <summary>
            UpdateKeys
            </summary>
            <param name="byeValue">byte</param>
        </member>
        <member name="P:HSS.IO.Zip.ZipCrypto.MagicByte">
            <summary> 
            From AppNote.txt:
            unsigned char decrypt_byte()
                local unsigned short temp
                temp :=- Key(2) | 2
                decrypt_byte := (temp * (temp ^ 1)) bitshift-right 8
            end decrypt_byte
            </summary>		
        </member>
        <member name="T:HSS.IO.Zip.ZipCipherStream">
            <summary>
            A Stream for reading and concurrently decrypting data from a zip file, 
            or for writing and concurrently encrypting data to a zip file.
            </summary>
        </member>
        <member name="M:HSS.IO.Zip.ZipCipherStream.#ctor(System.IO.Stream,HSS.IO.Zip.ZipCrypto,HSS.IO.Zip.CryptoMode)">
            <summary>
            The  constructor.
            </summary>
            <param name="s">The underlying stream</param>
            <param name="mode">To either encrypt or decrypt.</param>
            <param name="cipher">The pre-initialized ZipCrypto object.</param>
        </member>
        <member name="T:HSS.Data.Extensions">
            <summary>
            HSS.Data Extensions
            </summary>
        </member>
        <member name="M:HSS.Data.Extensions.ToXml(HSS.Data.IDataContainer)">
            <summary>
            Serializes an Object to Xml
            </summary>
            <param name="value">The Root Object</param>
            <returns>The Xml version of the instance</returns>
        </member>
        <member name="M:HSS.Data.Extensions.ToXmlFile(HSS.Data.IDataContainer,System.String)">
            <summary>
            A method for serializing an Instance of an object to an Xml File.
            </summary>
            <param name="value">The object to serialize to Xml</param>
            <param name="fileName">The file name and path where to write the object</param>
        </member>
        <member name="M:HSS.Data.Extensions.ToMemoryStream(HSS.Data.IDataContainer)">
            <summary>
            Serializes an Object to a MemoryStream
            </summary>
            <param name="value">The Root Object</param>
            <returns>The Binary version of the instance in a MemoryStream</returns>
        </member>
        <member name="M:HSS.Data.Extensions.ToByteArray(HSS.Data.IDataContainer)">
            <summary>
            Serializes an Object to an Array of Bytes
            </summary>
            <param name="value">The Root Object</param>
            <returns>The Binary version of the instance in an Array of Bytes</returns>
        </member>
        <member name="M:HSS.Data.Extensions.ToFile(HSS.Data.IDataContainer,System.String)">
            <summary>
            A method for serializing an Instance of an object to a File.
            </summary>
            <param name="value">The object to serialize to BinaryData</param>
            <param name="fileName">The file name and path where to write the object</param>
        </member>
        <member name="T:HSS.ServiceManager">
            <summary>
            ServiceManager provides a wrapper around basic Win32 Service, such as starting, stopping, retrieving the Service
            Description, Location or StartType.
            </summary>
        </member>
        <member name="M:HSS.ServiceManager.GetService(System.String)">
            <summary>
            Gets a ServiceManager Instance for the specified ServiceName
            </summary>
            <param name="serviceName">The name of the Service to retrieve</param>
            <returns>An instance of ServiceManager</returns>
        </member>
        <member name="M:HSS.ServiceManager.StopService(System.TimeSpan)">
            <summary>
            Stops the Service.
            </summary>
            <param name="waitTime">The amount of time to wait for the service to stop</param>
        </member>
        <member name="M:HSS.ServiceManager.StartService(System.TimeSpan)">
            <summary>
            Starts the Service.
            </summary>
            <param name="waitTime">The amount of time to wait for the service to start</param>
        </member>
        <member name="P:HSS.ServiceManager.ServiceName">
            <summary>
            Gets the Name of the Service.
            </summary>
        </member>
        <member name="P:HSS.ServiceManager.ServiceExist">
            <summary>
            Is the Service Installed?
            </summary>
        </member>
        <member name="P:HSS.ServiceManager.ServiceLocation">
            <summary>
            Gets the Service ImagePath.
            </summary>
        </member>
        <member name="P:HSS.ServiceManager.ServiceDescription">
            <summary>
            Gets the Service Description.
            </summary>
        </member>
        <member name="P:HSS.ServiceManager.ServiceStartType">
            <summary>
            Gets or sets the Service Start Type.
            </summary>
            <remarks>
            Automatic = 2
            Manual = 3
            Disabled = 4
            </remarks>
        </member>
        <member name="P:HSS.ServiceManager.IsServiceRunning">
            <summary>
            Is the Service Running.
            </summary>
        </member>
        <member name="T:HSS.Logging.Log">
            <summary>
            HSS Log Client provides interaction with the HSS Logging Service
            </summary>
        </member>
        <member name="T:HSS.Logging.ILog">
            <summary>
            The Interface for Application Logging
            </summary>
        </member>
        <member name="M:HSS.Logging.ILog.AttachFile(System.Int32,System.Byte[],System.String)">
            <summary>
            Save an attachment to a Database
            </summary>
            <param name="entryId">The Id of the pre-existing EventLog Entry to attach.</param>
            <param name="content">The Content of the Attachment.</param>
            <param name="fileName">The File Name associated with this attachment. Uses the extension of the file to determine the Content-Type.</param>
            <returns>The AttachmentID</returns>
            <exception cref="T:System.InvalidOperationException">You can only add attachments when the LogType is to Database.</exception>
        </member>
        <member name="M:HSS.Logging.ILog.AttachContent(System.Int32,System.Byte[],System.String,System.String,System.String)">
            <summary>
            Save an attachment to a Database
            </summary>
            <param name="entryId">The Id of the pre-existing EventLog Entry to attach.</param>
            <param name="content">The Content of the Attachment.</param>
            <param name="contentType">The Mime Content-Type of the Attachment.</param>
            <param name="fileNameWithOutExtention">The File Name associated with this attachment with out the extension (.ext).</param>
            <param name="extensionWithDot">The File Extension associated with this attachment (.ext).</param>
            <returns>The AttachmentID</returns>
            <exception cref="T:System.InvalidOperationException">You can only add attachments when the LogType is set to Database.</exception>
        </member>
        <member name="M:HSS.Logging.ILog.TruncateLog(System.Int32)">
            <summary>
            Truncate the Log, retaining the requested number of days
            </summary>
            <param name="daysToRetain">The number of days to retain</param>
        </member>
        <member name="M:HSS.Logging.ILog.WriteEvent(System.String,System.String,System.String,System.String,System.String,System.String,System.Diagnostics.EventLogEntryType)">
            <summary>
            Write an entry to a Log
            </summary>
            <param name="message">The message to write.</param>
            <param name="userName">The name of the person or program writing this message.</param>
            <param name="category">The category of the program that is writing this message.</param>
            <param name="xmlString">The Xml String to attach to this entry.</param>
            <param name="applicationName">The name of the application this entry is associated with.</param>
            <param name="referenceNumber">A reference number to associate with the entry.</param>
            <param name="eventType">The event type for the entry.</param>
            <exception cref="T:System.InvalidOperationException">Cannot write to the Log when it's closed.</exception>
            <returns>The id of the new entry</returns>
        </member>
        <member name="M:HSS.Logging.ILog.WriteEntry(HSS.Logging.LogEntry)">
            <summary>
            Write an entry to a Log
            </summary>
            <param name="entry">The Log Entry to write</param>
            <exception cref="T:System.InvalidOperationException">Cannot write to the Log when it's closed.</exception>
            <returns>The id of the new entry</returns>
        </member>
        <member name="P:HSS.Logging.ILog.LogType">
            <summary>
            The LogType
            </summary>
        </member>
        <member name="F:HSS.Logging.Log.HSSLoggingSchema">
            <summary>
            The Public Schema for the HSS Log Event entries (http://schemas.highspeed-solutions.net/core/2006/09/events/event).
            </summary>
        </member>
        <member name="F:HSS.Logging.Log.HSSLogServerURI">
            <summary>
            The URI to the HSS Log Service LogServer (net.pipe://hss/logservice/4000/logserver).
            </summary>
        </member>
        <member name="M:HSS.Logging.Log.#ctor">
            <summary>
            Constructs the Log using the HSSLogServerURI.
            </summary>
        </member>
        <member name="M:HSS.Logging.Log.#ctor(System.ComponentModel.IContainer)">
            <summary>
            Constructs the Log using the HSSLogServerURI.
            </summary>
            <param name="container">The parent container.</param>
        </member>
        <member name="M:HSS.Logging.Log.WarningEvent(System.String,System.String)">
            <summary>
            Write an entry to a Log
            </summary>
            <param name="message">The message to write.</param>
            <param name="category">The category of the program that is writing this message.</param>
        </member>
        <member name="M:HSS.Logging.Log.WarningEvent(System.String,System.String,System.String,System.String,System.String,System.String)">
            <summary>
            Write an entry to a Log
            </summary>
            <param name="message">The message to write.</param>
            <param name="userName">The name of the person or program writing this message.</param>
            <param name="category">The category of this message.</param>
            <param name="attachmentString">The Xml String to attach to this entry.</param>
            <param name="applicationName">The name of the application this event is associated with.</param>
            <param name="referenceNumber">A reference number to associate with the entry.</param>
        </member>
        <member name="M:HSS.Logging.Log.ErrorEvent(System.String,System.String)">
            <summary>
            Write an entry to a Log
            </summary>
            <param name="message">The message to write.</param>
            <param name="category">The category of this message.</param>
        </member>
        <member name="M:HSS.Logging.Log.ErrorEvent(System.String,System.String,System.String,System.String,System.String,System.String)">
            <summary>
            Write an entry to a Log
            </summary>
            <param name="message">The message to write.</param>
            <param name="userName">The name of the person or program writing this message.</param>
            <param name="category">The category of this message.</param>
            <param name="attachmentString">The Xml String to attach to this entry.</param>
            <param name="applicationName">The name of the application this event is associated with.</param>
            <param name="referenceNumber">A reference number to associate with the entry.</param>
        </member>
        <member name="M:HSS.Logging.Log.InformationEvent(System.String,System.String)">
            <summary>
            Write an entry to a Log
            </summary>
            <param name="message">The message to write.</param>
            <param name="category">The category of this message.</param>
        </member>
        <member name="M:HSS.Logging.Log.InformationEvent(System.String,System.String,System.String,System.String,System.String,System.String)">
            <summary>
            Write an entry to a Log
            </summary>
            <param name="message">The message to write.</param>
            <param name="userName">The name of the person or program writing this message.</param>
            <param name="category">The category of this message.</param>
            <param name="attachmentString">The Xml String to attach to this entry.</param>
            <param name="applicationName">The name of the application this event is associated with.</param>
            <param name="referenceNumber">A reference number to associate with the entry.</param>
        </member>
        <member name="M:HSS.Logging.Log.FailureAudit(System.String,System.String)">
            <summary>
            Write an entry to a Log
            </summary>
            <param name="category">The category of this message.</param>
            <param name="message">The message to write.</param>
        </member>
        <member name="M:HSS.Logging.Log.FailureAudit(System.String,System.String,System.String,System.String,System.String,System.String)">
            <summary>
            Write an entry to a Log
            </summary>
            <param name="message">The message to write.</param>
            <param name="userName">The name of the person or program writing this message.</param>
            <param name="category">The category of this message.</param>
            <param name="attachmentString">The Xml String to attach to this entry.</param>
            <param name="applicationName">The name of the application this event is associated with.</param>
            <param name="referenceNumber">A reference number to associate with the entry.</param>
        </member>
        <member name="M:HSS.Logging.Log.SuccessAudit(System.String,System.String)">
            <summary>
            Write an entry to a Log
            </summary>
            <param name="message">The message to write.</param>
            <param name="category">The category of this message.</param>
        </member>
        <member name="M:HSS.Logging.Log.SuccessAudit(System.String,System.String,System.String,System.String,System.String,System.String)">
            <summary>
            Write an entry to a Log
            </summary>
            <param name="message">The message to write.</param>
            <param name="userName">The name of the person or program writing this message.</param>
            <param name="category">The category of this message.</param>
            <param name="attachmentString">The Xml String to attach to this entry.</param>
            <param name="applicationName">The name of the application this event is associated with.</param>
            <param name="referenceNumber">A reference number to associate with the entry.</param>
        </member>
        <member name="M:HSS.Logging.Log.WriteException(System.Exception,System.String,System.String,System.String,System.String,System.String,System.Diagnostics.EventLogEntryType)">
            <summary>
            Write an exception entry to a Log
            </summary>
            <param name="exception">The originating exception to write.</param>
            <param name="userName">The name of the person or program writing this message.</param>
            <param name="category">The category of this message.</param>
            <param name="xmlString">The Xml String to attach to this entry.</param>
            <param name="applicationName">The name of the application this exception is associated with.</param>
            <param name="referenceNumber">A reference number to associate with the entry.</param>
            <param name="eventType">The <see cref="T:System.Diagnostics.EventLogEntryType"/> for the entry.</param>
        </member>
        <member name="M:HSS.Logging.Log.WriteToMachineEventLog(System.String,HSS.Logging.MachineEventLogSource)">
            <summary>
            Writes an Error Entry to the Machines Event Log
            </summary>
            <param name="message">The message to write</param>
            <param name="source">One of the <see cref="T:HSS.Logging.MachineEventLogSource"/> options</param>
        </member>
        <member name="M:HSS.Logging.Log.WriteToMachineEventLog(System.String,HSS.Logging.MachineEventLogSource,System.Diagnostics.EventLogEntryType)">
            <summary>
            Write an Entry to the Machines Event Log
            </summary>
            <param name="message">The message to write</param>
            <param name="source">One of the <see cref="T:HSS.Logging.MachineEventLogSource"/> options</param>
            <param name="eventType">The event type for the entry</param>
        </member>
        <member name="M:HSS.Logging.Log.WriteEntry(System.String,System.Diagnostics.EventLogEntryType,System.String,System.String,System.String,System.String,System.String)">
            <summary>
            Write an entry to a Log
            </summary>
            <param name="message">The message to write</param>
            <param name="eventType">The event type for the entry.</param>
            <param name="userName">The name of the person or program writing this message.</param>
            <param name="category">The category of this message.</param>
            <param name="applicationName">The name of the application this entry is associated with.</param>
            <param name="xmlString">The Xml String to attach to this entry.</param>
            <param name="referenceNumber">The reference number associated with this entry.</param>
            <exception cref="T:System.ComponentModel.InvalidEnumArgumentException">EventType is not a valid <see cref="T:System.Diagnostics.EventLogEntryType"></see>.</exception>
            <exception cref="T:System.ArgumentNullException">Missing the Message to write</exception>
            <exception cref="T:System.ArgumentNullException">Missing the User in which the message is from</exception>
            <exception cref="T:System.ArgumentNullException">Missing the Category the message is for</exception>
        </member>
        <member name="M:HSS.Logging.Log.WriteException(System.Exception,System.String,System.String,System.String,System.String,System.String)">
            <summary>
            Write an Exception to the Log.
            </summary>
            <param name="exception">The exception to write.</param>
            <param name="userName">The name of the user to associate with this entry.</param>
            <param name="category">The category of this entry.</param>
            <param name="applicationName">The name of the application to associate with this entry.</param>
            <param name="xmlString">An xml string to record with this entry.</param>
            <param name="referenceNumber">The reference number to associate with this entry.</param>
            <returns>The id of the new event log entry.</returns>
            <exception cref="T:System.ArgumentNullException">Missing the Exception to write.</exception>
        </member>
        <member name="M:HSS.Logging.Log.WriteInformation(System.String)">
            <summary>
            Write an informational entry to a Log
            </summary>
            <param name="message">The message to write.</param>
        </member>
        <member name="M:HSS.Logging.Log.WriteSuccess(System.String)">
            <summary>
            Write a success entry to a Log
            </summary>
            <param name="message">The message to write.</param>
        </member>
        <member name="M:HSS.Logging.Log.WriteFailure(System.String)">
            <summary>
            Write a failure entry to a Log
            </summary>
            <param name="message">The message to write.</param>
        </member>
        <member name="M:HSS.Logging.Log.WriteWarning(System.String)">
            <summary>
            Write a warning entry to a Log
            </summary>
            <param name="message">The message to write.</param>
        </member>
        <member name="M:HSS.Logging.Log.WriteError(System.String)">
            <summary>
            Write an error entry to a Log
            </summary>
            <param name="message">The message to write.</param>
        </member>
        <member name="M:HSS.Logging.Log.Ping">
            <summary>
            A method a client object can call to validate object existence
            </summary>
            <returns>true</returns>
        </member>
        <member name="M:HSS.Logging.Log.AttachFile(System.Int32,System.Byte[],System.String)">
            <summary>
            Save an attachment to the HSSLog Database
            </summary>
            <param name="entryId">The Id of the pre-existing Log Entry to attach.</param>
            <param name="content">The Content of the Attachment.</param>
            <param name="fileName">The File Name associated with this attachment. Uses the extension of the file to determine the Content-Type.</param>
            <returns>The AttachmentID</returns>
            <exception cref="T:System.InvalidOperationException">You can only add attachments when the LogType is to Database.</exception>
        </member>
        <member name="M:HSS.Logging.Log.AttachContent(System.Int32,System.Byte[],System.String,System.String,System.String)">
            <summary>
            Save an attachment to the HSSLog Database
            </summary>
            <param name="entryId">The Id of the pre-existing Log Entry to attach.</param>
            <param name="content">The Content of the Attachment.</param>
            <param name="contentType">The Mime Content-Type of the Attachment.</param>
            <param name="fileNameWithOutExtention">The File Name associated with this attachment with out the extension.</param>
            <param name="extensionWithDot">The File Extension associated with this attachment (.ext).</param>
            <returns>The AttachmentID</returns>
            <exception cref="T:System.InvalidOperationException">You can only add attachments when the LogType is to Database.</exception>
        </member>
        <member name="M:HSS.Logging.Log.TruncateLog(System.Int32)">
            <summary>
            Truncate the Log, retaining the requested number of days
            </summary>
            <param name="daysToRetain">The number of days to retain</param>
        </member>
        <member name="M:HSS.Logging.Log.WriteEvent(System.String,System.String,System.String,System.String,System.String,System.String,System.Diagnostics.EventLogEntryType)">
            <summary>
            Write an event message to the Log.
            </summary>
            <param name="message">The message to write.</param>
            <param name="userName">The name of the person or program writing this message.</param>
            <param name="category">The category of this message.</param>
            <param name="xmlString">The Xml String to attach to this entry.</param>
            <param name="applicationName">The name of the application this entry is associated with.</param>
            <param name="referenceNumber">A reference number to associate with the entry.</param>
            <param name="eventType">The event type for the entry.</param>
            <exception cref="T:System.ComponentModel.InvalidEnumArgumentException">EventType is not a valid <see cref="T:System.Diagnostics.EventLogEntryType"></see>.</exception>
            <exception cref="T:System.ArgumentNullException">Missing the Message to write</exception>
            <exception cref="T:System.ArgumentNullException">Missing the User in which the message is from</exception>
            <exception cref="T:System.ArgumentNullException">Missing the Category the message is for</exception>
        </member>
        <member name="M:HSS.Logging.Log.WriteEntry(HSS.Logging.LogEntry)">
            <summary>
            Write an entry to a Log
            </summary>
            <param name="entry">The Log Entry to write</param>
            <exception cref="T:System.ArgumentNullException">Missing the Entry to write</exception>
            <exception cref="T:System.ArgumentNullException">Missing the Message to write</exception>
            <exception cref="T:System.ArgumentNullException">Missing the User in which the message is from</exception>
            <exception cref="T:System.ArgumentNullException">Missing the Category the message is for</exception>
            <returns>The id of the new entry</returns>
        </member>
        <member name="F:HSS.Logging.Log.components">
            <summary>
            Required designer variable.
            </summary>
        </member>
        <member name="M:HSS.Logging.Log.Dispose(System.Boolean)">
            <summary> 
            Clean up any resources being used.
            </summary>
            <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
        </member>
        <member name="M:HSS.Logging.Log.InitializeComponent">
            <summary>
            Required method for Designer support - do not modify
            the contents of this method with the code editor.
            </summary>
        </member>
        <member name="P:HSS.Logging.Log.LogServerURI">
            <summary>
            Gets the URI to the LogServer.
            </summary>
        </member>
        <member name="P:HSS.Logging.Log.DefaultUserName">
            <summary>
            Gets or sets the default username to associate with a log entry
            </summary>
        </member>
        <member name="P:HSS.Logging.Log.DefaultApplicationName">
            <summary>
            Gets or sets the default name of the application associated with all new event entries.
            </summary>
        </member>
        <member name="P:HSS.Logging.Log.Formatter">
            <summary>
            Gets or sets the LogEntry formatter for the log
            </summary>
        </member>
        <member name="P:HSS.Logging.Log.LogType">
            <summary>
            Gets the LogType of the Logging Service
            </summary>
        </member>
        <member name="T:HSS.Logging.LogConfiguration">
            <summary>
            A class that represents an event log configuration
            </summary>
        </member>
        <member name="T:HSS.Logging.ILogConfiguration">
            <summary>
            Configuration config for a LogServer instance
            </summary>
        </member>
        <member name="T:HSS.IConfigurationElement">
            <summary>
            IConfigurationElement is the interface for a configuration data model.
            </summary>
        </member>
        <member name="P:HSS.IConfigurationElement.Name">
            <summary>
            The friendly name to refer to this instance by.
            </summary>
        </member>
        <member name="T:HSS.ISecuredConfigurationElement">
            <summary>
            This is a marker interface, indicating that any class that
            implements this interface should be encrypted when persisted.
            </summary>
        </member>
        <member name="M:HSS.Logging.ILogConfiguration.SaveInstance">
            <summary>
            Persists the current instance to file
            </summary>
        </member>
        <member name="P:HSS.Logging.ILogConfiguration.LogType">
            <summary>
            The Type of log to write event entries to
            </summary>
        </member>
        <member name="P:HSS.Logging.ILogConfiguration.AutoTruncate">
            <summary>
            Indicate whether or not to auto truncate the eventlog
            </summary>
        </member>
        <member name="P:HSS.Logging.ILogConfiguration.TruncateAt">
            <summary>
            If AutoTruncate is true indicates the time of day in which to execute the Truncate Command
            </summary>
        </member>
        <member name="P:HSS.Logging.ILogConfiguration.DaysToRetain">
            <summary>
            If AutoTruncate is true indicates the number of days to retain
            </summary>
        </member>
        <member name="P:HSS.Logging.ILogConfiguration.DbConnString">
            <summary>
            The Database ConnectionString
            </summary>
        </member>
        <member name="M:HSS.Logging.LogConfiguration.#ctor">
            <summary>
            Default Public CTOR 
            </summary>
            <remarks>Required for Serialization</remarks>
        </member>
        <member name="M:HSS.Logging.LogConfiguration.#ctor(System.String,System.String,HSS.Logging.EventLogType,System.Boolean,System.DateTime,System.Int32,System.String)">
            <summary>
            Creates a new EventLogConfiguration using the parameters
            </summary>
            <param name="id">The unique Id for this Configuration</param>
            <param name="name">The friendly name for this Configuration</param>
            <param name="logType">The Type of log to write event entries to</param>
            <param name="autoTruncate">Indicate whether or not to auto truncate the eventlog</param>
            <param name="truncateAt">If AutoTruncate is true indicates the time of day in which to execute the Truncate Command</param>
            <param name="daysToRetain">If AutoTruncate is true indicates the number of days to retain</param>
            <param name="dbConnString">The Id of the Database Configuration to use</param>
        </member>
        <member name="M:HSS.Logging.LogConfiguration.#ctor(HSS.Logging.LogConfiguration)">
            <summary>
            Creates a new EventLogConfiguration using the EventLog passed in
            </summary>
            <param name="eventLogConfig">Pre-existing EventLogConfiguration</param>
        </member>
        <member name="M:HSS.Logging.LogConfiguration.#cctor">
            <summary>
            Static Constructor
            </summary>
        </member>
        <member name="M:HSS.Logging.LogConfiguration.Clone">
            <summary>
            Create a shallow copy Clone of this object
            </summary>
            <returns>Returns a shallow copy of this object</returns>
        </member>
        <member name="M:HSS.Logging.LogConfiguration.ToString">
            <summary>
            The Name of the EventLog
            </summary>
            <returns>Name of the EventLog</returns>
        </member>
        <member name="M:HSS.Logging.LogConfiguration.LoadInstance">
            <summary>
            Load an instance from persisted Xml
            </summary>
            <returns>An instance of a LogConfiguration</returns>
        </member>
        <member name="M:HSS.Logging.LogConfiguration.SaveInstance">
            <summary>
            Persists the current instance to file
            </summary>
        </member>
        <member name="M:HSS.Logging.LogConfiguration.GetAppRoot">
            <summary>
            Extract the location where the LogConfiguration is installed. AKA, AppRoot
            </summary>
            <returns>The Folder Location of the AppRoot</returns>
        </member>
        <member name="M:HSS.Logging.LogConfiguration.GetBinFolder">
            <summary>
            Get the BIN Folder
            </summary>
            <returns>The Folder Location of the BIN</returns>
        </member>
        <member name="P:HSS.Logging.LogConfiguration.Id">
            <summary>
            The unique id for the data stored in this object.
            </summary>
        </member>
        <member name="P:HSS.Logging.LogConfiguration.Name">
            <summary>
            The friendly name for the data stored in this object.
            </summary>
        </member>
        <member name="P:HSS.Logging.LogConfiguration.Data">
            <summary>
            Returns a reference to the derived instance, as an Object.
            </summary>
        </member>
        <member name="P:HSS.Logging.LogConfiguration.LogType">
            <summary>
            The Type of log to write event entries to
            </summary>
        </member>
        <member name="P:HSS.Logging.LogConfiguration.AutoTruncate">
            <summary>
            Indicate whether or not to auto truncate the eventlog
            </summary>
        </member>
        <member name="P:HSS.Logging.LogConfiguration.TruncateAt">
            <summary>
            If AutoTruncate is true indicates the time of day in which to execute the Truncate Command
            </summary>
        </member>
        <member name="P:HSS.Logging.LogConfiguration.DaysToRetain">
            <summary>
            If AutoTruncate is true indicates the number of days to retain
            </summary>
        </member>
        <member name="P:HSS.Logging.LogConfiguration.DbConnString">
            <summary>
            The Id of the Database Configuration to use
            </summary>
        </member>
        <member name="T:HSS.InitializationException">
            <summary>
            An exception that is thrown if an Initialization Routine has failed
            </summary>
        </member>
        <member name="M:HSS.InitializationException.#ctor">
            <summary>
            ctor
            </summary>
        </member>
        <member name="M:HSS.InitializationException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
            <summary>
            ctor
            </summary>
            <param name="info">SerializationInfo</param>
            <param name="context">StreamingContext</param>
        </member>
        <member name="M:HSS.InitializationException.#ctor(System.String)">
            <summary>
            ctor
            </summary>
            <param name="message">The exception message</param>
        </member>
        <member name="M:HSS.InitializationException.#ctor(System.String,System.Exception)">
            <summary>
            ctor
            </summary>
            <param name="message">The exception message</param>
            <param name="inner">The inner exception that this exception came from</param>
        </member>
        <member name="T:HSS.Threading.ITimerService">
            <summary>
            The interface that a class can implement, that hosts one or more <see cref="T:HSS.Threading.Timer"/>s
            </summary>
        </member>
        <member name="M:HSS.Threading.ITimerService.OnTick(HSS.Threading.Timer)">
            <summary>
            The method called by a <see cref="T:HSS.Threading.Timer"/> when the timer has ticked
            <para>
            <b>NOTE:</b> This method callback is not threadsafe.
            </para>
            </summary>
            <param name="sourceTimer">The source <see cref="T:HSS.Threading.Timer"/></param>
        </member>
        <member name="T:HSS.IO.Zip.CRC32">
            <summary>
            Calculates a 32bit Cyclic Redundancy Checksum (CRC) using the
            same polynomial used by Zip. This type ie generally not used directly
            by applications wishing to create, read, or manipulate zip archive files.
            </summary>
        </member>
        <member name="M:HSS.IO.Zip.CRC32.GetCrc32(System.IO.Stream)">
            <summary>
            Returns the CRC32 for the specified stream.
            </summary>
            <param name="input">The stream over which to calculate the CRC32</param>
            <returns>the CRC32 calculation</returns>
        </member>
        <member name="M:HSS.IO.Zip.CRC32.GetCrc32AndCopy(System.IO.Stream,System.IO.Stream)">
            <summary>
            Returns the CRC32 for the specified stream, and writes the input into the output stream.
            </summary>
            <param name="input">The stream over which to calculate the CRC32</param>
            <param name="output">The stream into which to deflate the input</param>
            <returns>the CRC32 calculation</returns>
        </member>
        <member name="M:HSS.IO.Zip.CRC32.ComputeCrc32(System.Int32,System.Byte)">
            <summary>
            Get the CRC32 for the given (word,byte) combo. 
            This is a computation defined by PKzip.
            </summary>
            <param name="W">The word to start with.</param>
            <param name="B">The byte to combine it with.</param>
            <returns>The CRC-ized result.</returns>
        </member>
        <member name="M:HSS.IO.Zip.CRC32.SlurpBlock(System.Byte[],System.Int32,System.Int32)">
            <summary>
            Update the value for the running CRC32 using the given block of bytes.
            This is useful when using the CRC32() class in a Stream.
            </summary>
            <param name="block">block of bytes to slurp</param>
            <param name="offset">starting point in the block</param>
            <param name="count">how many bytes within the block to slurp</param>
        </member>
        <member name="M:HSS.IO.Zip.CRC32.#ctor">
            <summary>
            Construct an instance of the CRC32 class, pre-initialising the table
            for speed of lookup.
            </summary>
        </member>
        <member name="P:HSS.IO.Zip.CRC32.TotalBytesRead">
            <summary>
            indicates the total number of bytes read on the CRC stream.
            This is used when writing the ZipDirEntry when compressing files.
            </summary>
        </member>
        <member name="P:HSS.IO.Zip.CRC32.Crc32Result">
            <summary>
            Indicates the current CRC for all blocks slurped in.
            </summary>
        </member>
        <member name="T:HSS.IO.Zip.CrcCalculatorStream">
             <summary>
             A read-only, forward-only Stream that calculates a CRC, a checksum, on all bytes read, 
             or on all bytes written.
             </summary>
            
             <remarks>
             This class can be used to verify the CRC of a ZipEntry when reading from a stream, 
             or to calculate a CRC when writing to a stream.  The stream should be used to either 
             read, or write, but not both.  If you intermix reads and writes, the results are
             not defined.
             </remarks>
        </member>
        <member name="M:HSS.IO.Zip.CrcCalculatorStream.#ctor(System.IO.Stream)">
            <summary>
            The constructor.
            </summary>
            <param name="stream">The underlying stream</param>
        </member>
        <member name="M:HSS.IO.Zip.CrcCalculatorStream.#ctor(System.IO.Stream,System.Int32)">
            <summary>
            The constructor.
            </summary>
            <param name="stream">The underlying stream</param>
            <param name="length">The length of the stream to slurp</param>
        </member>
        <member name="M:HSS.IO.Zip.CrcCalculatorStream.Read(System.Byte[],System.Int32,System.Int32)">
            <summary>
            Read from the stream
            </summary>
            <param name="buffer">the buffer to read</param>
            <param name="offset">the offset at which to start</param>
            <param name="count">the number of bytes to read</param>
            <returns>the number of bytes actually read</returns>
        </member>
        <member name="M:HSS.IO.Zip.CrcCalculatorStream.Write(System.Byte[],System.Int32,System.Int32)">
            <summary>
            Write to the stream. 
            </summary>
            <param name="buffer">the buffer from which to write</param>
            <param name="offset">the offset at which to start writing</param>
            <param name="count">the number of bytes to write</param>
        </member>
        <member name="M:HSS.IO.Zip.CrcCalculatorStream.Flush">
            <summary>
            Not implemented.
            </summary>
        </member>
        <member name="M:HSS.IO.Zip.CrcCalculatorStream.Seek(System.Int64,System.IO.SeekOrigin)">
            <summary>
            Not implemented.
            </summary>
            <param name="offset">N/A</param>
            <param name="origin">N/A</param>
            <returns>N/A</returns>
        </member>
        <member name="M:HSS.IO.Zip.CrcCalculatorStream.SetLength(System.Int64)">
            <summary>
            Not implemented.
            </summary>
            <param name="value">N/A</param>
        </member>
        <member name="P:HSS.IO.Zip.CrcCalculatorStream.TotalBytesSlurped">
             <summary>
             Gets the total number of bytes run through the CRC32 calculator.
             </summary>
            
             <remarks>
             This is either the total number of bytes read, or the total number
             of bytes written, depending on the direction of this stream.
             </remarks>
        </member>
        <member name="P:HSS.IO.Zip.CrcCalculatorStream.Crc32">
            <summary>
            Provides the current CRC for all blocks slurped in.
            </summary>
        </member>
        <member name="P:HSS.IO.Zip.CrcCalculatorStream.CanRead">
            <summary>
            Indicates whether the stream supports reading. Always returns true.
            </summary>
        </member>
        <member name="P:HSS.IO.Zip.CrcCalculatorStream.CanSeek">
            <summary>
            Indicates whether the stream supports seeking. Always returns false.
            </summary>
        </member>
        <member name="P:HSS.IO.Zip.CrcCalculatorStream.CanWrite">
            <summary>
            Indicates whether the stream supports writing. Always returns true.
            </summary>
        </member>
        <member name="P:HSS.IO.Zip.CrcCalculatorStream.Length">
            <summary>
            Not implemented.
            </summary>
        </member>
        <member name="P:HSS.IO.Zip.CrcCalculatorStream.Position">
            <summary>
            Not implemented.
            </summary>
        </member>
        <member name="T:HSS.Data.WrappedDataContainer">
            <summary>
            WrappedDataContainer is a simple implementation of IDataContainer and provides 
            wrapper functionality so that other objects can be shared with HSS Objects 
            and Components via the <see cref="T:HSS.Data.IDataContainer"/> interface. Normally, a
            class would have properties representing it's data (object model), but this
            is a wrapper class and just has the one property (this.Data) which contains
            the wrapped object.
            </summary>
        </member>
        <member name="M:HSS.Data.WrappedDataContainer.#ctor(System.String,System.Object)">
            <summary>
            Default CTOR
            </summary>
        </member>
        <member name="M:HSS.Data.WrappedDataContainer.#ctor(System.String,System.String,System.Object)">
            <summary>
            Default CTOR
            </summary>
        </member>
        <member name="M:HSS.Data.WrappedDataContainer.CreateWrappedDataContainerCollection(System.Collections.IEnumerable)">
            <summary>
            Creates a Collection of type DataContainer using the order index as the Id and Name
            </summary>
            <param name="listData">The IEnumerable list of objects</param>
            <returns>A Collection of type DataContainer containing the objects</returns>
        </member>
        <member name="M:HSS.Data.WrappedDataContainer.CreateIDataContainerCollection(System.Collections.IEnumerable)">
            <summary>
            Creates a Collection of type IDataContainer using the order index as the Id and Name
            </summary>
            <param name="listData">The IEnumerable list of objects</param>
            <returns>A Collection of type IDataContainer containing the objects</returns>
        </member>
        <member name="P:HSS.Data.WrappedDataContainer.Id">
            <summary>
            The Unique Id for the Data contained in an instance of this class.
            </summary>
        </member>
        <member name="P:HSS.Data.WrappedDataContainer.Name">
            <summary>
            The friendly name to refer to this instance by.
            </summary>
        </member>
        <member name="P:HSS.Data.WrappedDataContainer.Data">
            <summary>
            The data contained in this object
            </summary>
        </member>
        <member name="T:HSS.AsyncResultNoResult">
            <summary>
            A basic implementation of <see cref="T:System.IAsyncResult"/> with out any results
            </summary>
            <remarks>Courtesy of Jeffrey Richter (http://msdn.microsoft.com/msdnmag/issues/07/03/ConcurrentAffairs/)</remarks>
        </member>
        <member name="M:HSS.AsyncResultNoResult.#ctor(System.AsyncCallback)">
            <summary>
            Constructor
            </summary>
            <param name="asyncCallback">The AsyncCallback callback</param>
        </member>
        <member name="M:HSS.AsyncResultNoResult.#ctor(System.AsyncCallback,System.Object)">
            <summary>
            Constructor
            </summary>
            <param name="asyncCallback">The AsyncCallback callback</param>
            <param name="state">Any object state</param>
        </member>
        <member name="M:HSS.AsyncResultNoResult.SetAsCompleted(System.Exception,System.Boolean)">
            <summary>
            Indicate that the operation is complete
            </summary>
            <param name="exception">Any exceptions encountered or null</param>
            <param name="completedSynchronously">Did it complete Synchronously</param>
        </member>
        <member name="M:HSS.AsyncResultNoResult.EndInvoke">
            <summary>
            End the async operation, waiting for it to complete
            </summary>
        </member>
        <member name="P:HSS.AsyncResultNoResult.AsyncState">
            <summary>
            Gets the associated object state
            </summary>
        </member>
        <member name="P:HSS.AsyncResultNoResult.CompletedSynchronously">
            <summary>
            Did the operation complete Async
            </summary>
        </member>
        <member name="P:HSS.AsyncResultNoResult.AsyncWaitHandle">
            <summary>
            Gets the WaitHandle associated with this result
            </summary>
        </member>
        <member name="P:HSS.AsyncResultNoResult.IsCompleted">
            <summary>
            Is the Async Operation Completed
            </summary>
        </member>
        <member name="T:HSS.Threading.MutexHelper">
            <summary>
            A helper class providing syncronous access across boundries
            </summary>
            <remarks>
            This mutex helper is intended to simplify locking access to a globally available resource and
            to syncronize that access. It requires a Name (Named Mutex), and sets the security on the
            Mutex itself to "All Users" so that mutliple applications/users can share synchorized access.
            It is not intended to provide security to the actual syncronized resource. That 
            is left the developer to ensure resources are not accessed by unathorized users.
            </remarks>
            <example>
            <code>
            using (MutexHelper mtx = new MutexHelper("Global Unique Name"))
            {
            	if (mtx.Acquired)
            	{
            		// Perform logic here to access protected resource(s)
            		// File.Write or Read
            	}
            } // On Dispose releases the mutex
            </code>
            </example>
        </member>
        <member name="M:HSS.Threading.MutexHelper.#ctor(System.String)">
            <summary>
            Open or create the named Mutex and attempt to acquire
            </summary>
            <param name="MutexName">The name of the mutex to acquire</param>
        </member>
        <member name="M:HSS.Threading.MutexHelper.#ctor(System.String,System.Boolean,System.Int32)">
            <summary>
            Open or create a Named Mutex and attempt to acquire if requested
            </summary>
            <param name="MutexName">The name of the mutex to open or create</param>
            <param name="Acquire">Should we attempt to acquire the Mutex</param>
            <param name="WaitTime">If Acquire is true, the time in milliseconds to wait</param>
            <exception cref="T:System.ApplicationException">Acquire is true and WaitTime is less than -1</exception>
            <exception cref="T:System.UnauthorizedAccessException">Caller is not authorized to access, open or create the Named Mutex</exception>
        </member>
        <member name="M:HSS.Threading.MutexHelper.Dispose">
            <summary>
            Release the Mutex
            </summary>
        </member>
        <member name="P:HSS.Threading.MutexHelper.Acquired">
            <summary>
            Do we currently own the mutex
            </summary>
        </member>
        <member name="T:HSS.Logging.ValidationResults">
            <summary>
            Information determined when validating a connection to the logging database
            </summary>
        </member>
        <member name="M:HSS.Logging.ValidationResults.#ctor">
            <summary>
            ctor
            </summary>
        </member>
        <member name="P:HSS.Logging.ValidationResults.Message">
            <summary>
            Result message
            </summary>
        </member>
        <member name="P:HSS.Logging.ValidationResults.Success">
            <summary>
            Indicate of the connection is valid
            </summary>
        </member>
        <member name="P:HSS.Logging.ValidationResults.Error">
            <summary>
            Any exceptions encountered
            </summary>
        </member>
        <member name="P:HSS.Logging.ValidationResults.ShowVerbose">
            <summary>
            Indicate if the <see cref="P:HSS.Logging.ValidationResults.Message"/> should be shown to the user
            </summary>
        </member>
        <member name="P:HSS.Logging.ValidationResults.CoreDBInstalled">
            <summary>
            Is the HSS Core DB Installed
            </summary>
        </member>
        <member name="T:HSS.Logging.EventLogType">
            <summary>
            The Type of log to write event entries to
            </summary>
        </member>
        <member name="F:HSS.Logging.EventLogType.Database">
            <summary>
            Write event entries to a database
            </summary>
        </member>
        <member name="F:HSS.Logging.EventLogType.Machine">
            <summary>
            Write event entries to the Machines EventLog
            </summary>
        </member>
        <member name="T:HSS.Logging.DefaultFormatter">
            <summary>
            The Default Log Formatter
            </summary>
        </member>
        <member name="T:HSS.Logging.ILogEntryFormatter">
            <summary>
            The ILogEntryFormatter provides the contract for formatting a Log Entry prior to being written to the actual log.
            </summary>
        </member>
        <member name="M:HSS.Logging.ILogEntryFormatter.Format(HSS.Logging.LogEntry,HSS.Logging.ILog)">
            <summary>
            A call to this method allows for altering the given Log Entry prior to being written to the actual log.
            </summary>
            <param name="entry">The original entry prior to being written to the log</param>
            <param name="log">The source log instance</param>
        </member>
        <member name="M:HSS.Logging.ILogEntryFormatter.FormatException(System.Exception,HSS.Logging.LogEntry,HSS.Logging.ILog)">
            <summary>
            A call to this method allows for altering the given Log Entry prior to being written to the actual log.
            </summary>
            <param name="ex">The exception to be processed</param>
            <param name="entry">The original entry prior to being written to the log</param>
            <param name="log">The source log instance</param>
        </member>
        <member name="M:HSS.Logging.DefaultFormatter.Format(HSS.Logging.LogEntry,HSS.Logging.ILog)">
            <summary>
            Does not format the entry
            </summary>
            <param name="entry">The originatign entry</param>
            <param name="log">The source log instance</param>
        </member>
        <member name="M:HSS.Logging.DefaultFormatter.FormatException(System.Exception,HSS.Logging.LogEntry,HSS.Logging.ILog)">
            <summary>
            A call to this method allows for altering the given Log Entry prior to being written to the actual log
            </summary>
            <param name="ex">The exception to be processed</param>
            <param name="entry">The original entry prior to being written to the log</param>
            <param name="log">The source log instance</param>
        </member>
        <member name="T:HSS.IO.Zip.ZipConstants">
            <summary>
            ZipConstants
            </summary>
        </member>
        <member name="T:HSS.IO.Zip.RereadApprovalCallback">
            <summary>
            Delegate for the callback by which the application gives approval for multiple
            reads of the file stream. This callback is called only when the initial 
            compression operation inflates the size of the file data. 
            </summary>
        </member>
        <member name="T:HSS.IO.Zip.WantCompressionCallback">
            <summary>
            Delegate for the callback by which the application tells the libraary whether
            to use compression on the file or not.  Using this callback, the application can 
            specify that previously-compressed files (.mp3, .png, .docx, etc) should 
            not be compressed, for example, or can turn on or off compression based on any 
            other factor.
            </summary>
        </member>
        <member name="T:HSS.IO.Zip.ZipProgressEventArgs">
            <summary>
            Provides information about the progress of a save or extract operation.
            </summary>
        </member>
        <member name="P:HSS.IO.Zip.ZipProgressEventArgs.EntriesTotal">
            <summary>
            The total number of entries to be saved or extracted.
            </summary>
        </member>
        <member name="P:HSS.IO.Zip.ZipProgressEventArgs.NameOfLatestEntry">
            <summary>
            The name of the last entry saved or extracted.
            </summary>
        </member>
        <member name="P:HSS.IO.Zip.ZipProgressEventArgs.Cancel">
            <summary>
            In an event handler, set this to cancel the save or extract 
            operation that is in progress.
            </summary>
        </member>
        <member name="T:HSS.IO.Zip.SaveProgressEventArgs">
            <summary>
            Provides information about the progress of a save operation.
            </summary>
        </member>
        <member name="M:HSS.IO.Zip.SaveProgressEventArgs.#ctor(System.Int32,System.Int32,System.String)">
            <summary>
            Constructor for the SaveProgressEventArgs.
            </summary>
            <param name="entriesTotal">The total number of entries in the zip archive.</param>
            <param name="entriesSaved">Number of entries that have been saved.</param>
            <param name="lastEntry">The last entry saved.</param>
        </member>
        <member name="P:HSS.IO.Zip.SaveProgressEventArgs.EntriesSaved">
            <summary>
            Number of entries saved so far.
            </summary>
        </member>
        <member name="T:HSS.IO.Zip.ExtractProgressEventArgs">
            <summary>
            Provides information about the progress of the extract operation.
            </summary>
        </member>
        <member name="M:HSS.IO.Zip.ExtractProgressEventArgs.#ctor(System.Int32,System.Int32,System.String,System.String,System.Boolean)">
            <summary>
            Constructor for the ExtractProgressEventArgs.
            </summary>
            <param name="entriesTotal">The total number of entries in the zip archive.</param>
            <param name="entriesExtracted">Number of entries that have been extracted.</param>
            <param name="lastEntry">The last entry extracted.</param>
            <param name="extractLocation">The location to which entries are extracted.</param>
            <param name="wantOverwrite">indicates whether the extract operation will overwrite existing files.</param>
        </member>
        <member name="P:HSS.IO.Zip.ExtractProgressEventArgs.EntriesExtracted">
            <summary>
            Number of entries extracted so far.
            </summary>
        </member>
        <member name="P:HSS.IO.Zip.ExtractProgressEventArgs.Overwrite">
            <summary>
            True if the extract operation overwrites existing files.
            </summary>
        </member>
        <member name="P:HSS.IO.Zip.ExtractProgressEventArgs.ExtractLocation">
            <summary>
            Returns the extraction target location, a filesystem path. 
            </summary>
        </member>
        <member name="T:HSS.IO.Zip.SaveEventArgs">
            <summary>
            Used to provide event information about the Save .
            </summary>
        </member>
        <member name="M:HSS.IO.Zip.SaveEventArgs.#ctor(System.String)">
            <summary>
            Constructor for a SaveEventArgs.
            </summary>
            <param name="archiveName">The name of the archive being saved.</param>
        </member>
        <member name="P:HSS.IO.Zip.SaveEventArgs.ArchiveName">
            <summary>
            Returns the archive name.
            </summary>
        </member>
        <member name="T:HSS.IO.Zip.ExtractEventArgs">
            <summary>
            Used to provide event information about the Extract operation.
            </summary>
        </member>
        <member name="M:HSS.IO.Zip.ExtractEventArgs.#ctor(System.String,System.String,System.Boolean)">
            <summary>
            Constructor for a ExtractEventArgs.
            </summary>
            <param name="archiveName">The name of the archive being extracted.</param>
            <param name="extractLocation">The location to which  the archive is being extracted.</param>
            <param name="wantOverwrite">whether the extract operation overwrites existing files.</param>
        </member>
        <member name="P:HSS.IO.Zip.ExtractEventArgs.ArchiveName">
            <summary>
            Returns the archive name.
            </summary>
        </member>
        <member name="P:HSS.IO.Zip.ExtractEventArgs.ExtractLocation">
            <summary>
            Returns the extraction target location, or "(stream)" if the target is a stream.
            </summary>
        </member>
        <member name="P:HSS.IO.Zip.ExtractEventArgs.Overwrite">
            <summary>
            A boolean indicating whether the extract operation overwrites existing files.
            </summary>
        </member>
        <member name="T:HSS.Extensions">
            <summary>
            HSS Extension Methods
            </summary>
        </member>
        <member name="M:HSS.Extensions.ToEncryptedString(HSS.IConfigurationElement,System.String)">
            <summary>
            Serializes the current instance using a BinaryFormatter and encrypts the resulting binary data using the provided password.
            </summary>
            <param name="instance">The IConfigurationElement instance</param>
            <param name="password">The password to encrypt this instance.</param>
            <returns>A BASE64 string.</returns>
        </member>
        <member name="M:HSS.Extensions.ToByteArray(HSS.IConfigurationElement)">
            <summary>
            Serializes an IConfigurationElement instance to an Array of Bytes
            </summary>
            <param name="value">The IConfigurationElement instance</param>
            <returns>The Binary version of the instance as an Array of Bytes</returns>
        </member>
        <member name="T:HSS.CoreInstaller">
            <summary>
            HSS Core Installer
            </summary>
        </member>
        <member name="M:HSS.CoreInstaller.#ctor">
            <summary>
            Constructor
            </summary>
        </member>
        <member name="M:HSS.CoreInstaller.Install(System.Collections.IDictionary)">
            <summary>
            Install custom actions
            </summary>
            <param name="stateSaver"></param>
        </member>
        <member name="M:HSS.CoreInstaller.Rollback(System.Collections.IDictionary)">
            <summary>
            Rollback custom actions
            </summary>
            <param name="savedState"></param>
        </member>
        <member name="M:HSS.CoreInstaller.Uninstall(System.Collections.IDictionary)">
            <summary>
            Uninstall custom actions
            </summary>
            <param name="savedState"></param>
        </member>
        <member name="F:HSS.CoreInstaller.components">
            <summary>
            Required designer variable.
            </summary>
        </member>
        <member name="M:HSS.CoreInstaller.Dispose(System.Boolean)">
            <summary> 
            Clean up any resources being used.
            </summary>
            <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
        </member>
        <member name="M:HSS.CoreInstaller.InitializeComponent">
            <summary>
            Required method for Designer support - do not modify
            the contents of this method with the code editor.
            </summary>
        </member>
        <member name="T:HSS.Data.DataRowReader">
            <summary>
            Provides read only, forward only, access to rows of data. This object is 
            similar to the <see cref="T:System.Data.Common.DbDataReader"/>, except there is no connection
            to a Database.
            <para>
            The DataRowReader supports 
            parsing data from a <see cref="T:System.Data.Common.DbDataReader"/>, an <see cref="T:System.Xml.XmlNodeList"/>
            or a <see cref="T:System.IO.TextReader"/> and allows manually adding additional rows 
            of data using the <c>AddRow</c> methods.
            </para>
            </summary>
        </member>
        <member name="M:HSS.Data.DataRowReader.#ctor">
            <summary>
            Default ctor
            </summary>
        </member>
        <member name="M:HSS.Data.DataRowReader.#ctor(System.Data.Common.DbDataReader)">
            <summary>
             Reads all rows from the DbDataReader closing and setting to null when done
            </summary>
            <param name="dr">The DbDataReader to parse</param>
        </member>
        <member name="M:HSS.Data.DataRowReader.#ctor(System.Xml.XmlNodeList)">
            <summary>
            Reads each node in the List as a Row of data and each ChildNode as a field within the row.
            The ChildNode Name represents a field name and the
            the ChildNode InnerText represents a field value
            </summary>
            <param name="nl">The XmlNodeList to parse</param>
        </member>
        <member name="M:HSS.Data.DataRowReader.#ctor(System.IO.TextReader,System.String,System.String,System.Int32)">
            <summary>
            Reads all lines as the rows of data.
            </summary>
            <param name="reader">The TextReader to parse.</param>
            <param name="delimeter">The delimeter to parse column names and values.</param>
            <param name="columnNames">A string containing the column names seperated by the parameter passed in the <paramref name="delimeter"/> parameter.</param>
            <param name="columnCount">The number of columns to parse.</param>
        </member>
        <member name="M:HSS.Data.DataRowReader.#ctor(System.IO.TextReader,System.String,System.String)">
            <summary>
            Reads all lines as the rows of data.
            </summary>
            <param name="reader">The TextReader to parse.</param>
            <param name="delimeter">The delimeter to parse column names and values.</param>
            <param name="columnNames">A string containing the column names seperated by the parameter passed in the <paramref name="delimeter"/> parameter.</param>
        </member>
        <member name="M:HSS.Data.DataRowReader.#ctor(System.IO.TextReader,System.String,System.String[])">
            <summary>
            Reads all lines as the rows of data.
            </summary>
            <param name="reader">The TextReader to parse.</param>
            <param name="delimeter">The delimeter to parse column names and values.</param>
            <param name="columnNames">A string array containing the column names.</param>
        </member>
        <member name="M:HSS.Data.DataRowReader.#ctor(System.IO.TextReader,System.String)">
            <summary>
            Reads the first line as the column headers, and then the rest of the lines as the rows of data.
            </summary>
            <param name="reader">The TextReader to parse.</param>
            <param name="delimeter">The delimeter to parse column Name and values.</param>
        </member>
        <member name="M:HSS.Data.DataRowReader.AddRow(System.Object[],System.String[],System.Boolean)">
            <summary>
            Adds one row of data to the DataRowReader
            </summary>
            <param name="values">The array of objects to add</param>
            <param name="columnNames">The array of object field names</param>
            <param name="reset">True to clear out the existing rows of data. Does not clear the ColumnNames</param>
            <returns>True if addition was successful</returns>
        </member>
        <member name="M:HSS.Data.DataRowReader.AddRow(System.Object[],System.String[])">
            <summary>
            Adds one row of data to the DataRowReader
            </summary>
            <param name="values">The array of objects to add</param>
            <param name="columnNames">The array of object field names</param>
            <returns>True if addition was successful</returns>
        </member>
        <member name="M:HSS.Data.DataRowReader.AddRow(System.Object[])">
            <summary>
            Adds one row of data to the DataRowReader
            </summary>
            <param name="values">The array of objects to add</param>
            <returns>True if addition was successful</returns>
        </member>
        <member name="M:HSS.Data.DataRowReader.GetRow">
            <summary>
            Get the Current Row of Data as an Object Array
            </summary>
            <returns>The current row as an Object Array</returns>
        </member>
        <member name="M:HSS.Data.DataRowReader.GetRow(System.Boolean)">
            <summary>
            Get the Current Row of Data as a String Array
            </summary>
            <param name="Trim">If true, will call Trim on the string</param>
            <returns>The current row as a string Array</returns>
        </member>
        <member name="M:HSS.Data.DataRowReader.NextResult">
            <summary>
            Not implemented
            </summary>
            <returns>false</returns>
        </member>
        <member name="M:HSS.Data.DataRowReader.Close">
            <summary>
            Closes the Data Row Reader and clears the underlying cache.
            </summary>
        </member>
        <member name="M:HSS.Data.DataRowReader.Read">
            <summary>
            Reads the next row of data, if available.
            </summary>
            <returns>False if the no more rows.</returns>
            <exception cref="T:System.ObjectDisposedException">If the DataRowReader has been closed or disposed</exception>
        </member>
        <member name="M:HSS.Data.DataRowReader.GetSchemaTable">
            <summary>
            Not implemented
            </summary>
            <returns>null</returns>
        </member>
        <member name="M:HSS.Data.DataRowReader.Dispose">
            <summary>
            Disposes the underlying cache.
            </summary>
        </member>
        <member name="M:HSS.Data.DataRowReader.GetBoolean(System.Int32)">
            <summary>
            Gets the value of the specified field as a Boolean.
            </summary>
            <param name="i">The zero-based field index.</param>
            <returns>The value of the field.</returns>
            <remarks>
            <para>
            The data retrieved must already be of the requested type or a string that can be parsed to the requested type, or an exception is generated.
            </para>
            <para>
            Call <see cref="M:HSS.Data.DataRowReader.IsDBNull(System.Int32)"/> to check for null values before calling this method or set <see cref="P:HSS.Data.DataRowReader.ValidateNull"/> to <c>false</c>.
            </para>
            <para>
            To bypass Type validation, set <see cref="P:HSS.Data.DataRowReader.ValidateType"/> to <c>false</c>. When false, will return the default Boolean value.
            </para>
            <para>
            To bypass Empty String validation (when underlying value is a string), set <see cref="P:HSS.Data.DataRowReader.ValidateEmptyString"/> to <c>false</c>. When false, will return the default Boolean value.
            </para>
            </remarks>
            <exception cref="T:System.IndexOutOfRangeException">The index passed was outside the range of 0 through <see cref="P:HSS.Data.DataRowReader.FieldCount"/>.</exception>
            <exception cref="T:System.NullReferenceException">The value 'null' was found where an instance of an object was required.</exception>
            <exception cref="T:System.InvalidCastException">The specified cast is not valid; the underlying value must be of type Boolean or String.</exception>
            <exception cref="T:System.InvalidOperationException">The value is an empty string and cannot be parsed into a valid Boolean.</exception>
        </member>
        <member name="M:HSS.Data.DataRowReader.GetByte(System.Int32)">
            <summary>
            Gets the 8-bit unsigned integer value of the specified field.
            </summary>
            <param name="i">The zero-based field index.</param>
            <returns>The 8-bit unsigned integer value of the specified field.</returns>
            <remarks>
            <para>
            The data retrieved must already be of the requested type or a string that can be parsed to the requested type, or an exception is generated.
            </para>
            <para>
            Call <see cref="M:HSS.Data.DataRowReader.IsDBNull(System.Int32)"/> to check for null values before calling this method or set <see cref="P:HSS.Data.DataRowReader.ValidateNull"/> to <c>false</c>.
            </para>
            <para>
            To bypass Type validation, set <see cref="P:HSS.Data.DataRowReader.ValidateType"/> to <c>false</c>. When false, will return the default Byte value.
            </para>
            <para>
            To bypass Empty String validation (when underlying value is a string), set <see cref="P:HSS.Data.DataRowReader.ValidateEmptyString"/> to <c>false</c>. When false, will return the default Byte value.
            </para>
            </remarks>
            <exception cref="T:System.IndexOutOfRangeException">The index passed was outside the range of 0 through <see cref="P:HSS.Data.DataRowReader.FieldCount"/>.</exception>
            <exception cref="T:System.NullReferenceException">The value 'null' was found where an instance of an object was required.</exception>
            <exception cref="T:System.InvalidCastException">The specified cast is not valid; the underlying value must be of type Byte or String.</exception>
            <exception cref="T:System.InvalidOperationException">The value is an empty string and cannot be parsed into a valid Byte.</exception>
        </member>
        <member name="M:HSS.Data.DataRowReader.GetBytes(System.Int32,System.Int64,System.Byte[],System.Int32,System.Int32)">
            <summary>
             Reads a stream of bytes from the specified field offset into the buffer as an array, starting at the given buffer offset.
            </summary>
            <param name="i">The zero-based field index.</param>
            <param name="fieldOffset">The index within the field from which to start the read operation.</param>
            <param name="buffer">The buffer into which to read the stream of bytes.</param>
            <param name="bufferOffset">The index for buffer to start the read operation.</param>
            <param name="length">The number of bytes to read.</param>
            <returns>The actual number of bytes read.</returns>
            <remarks>Assumes the underlying object value is either a string or already a byte array. If the value is a string converts it to a byte array using UTF8 Encoding.</remarks>
            <exception cref="T:System.InvalidCastException">There is a type mismatch.</exception>
            <exception cref="T:System.IndexOutOfRangeException">The index passed was outside the range of 0 through <see cref="P:HSS.Data.DataRowReader.FieldCount"></see>.</exception>
            <exception cref="T:System.NullReferenceException">The field specified by ordinal is null.</exception>
        </member>
        <member name="M:HSS.Data.DataRowReader.GetChars(System.Int32,System.Int64,System.Char[],System.Int32,System.Int32)">
            <summary>
            Reads a stream of characters from the specified field offset into the buffer as an array, starting at the given buffer offset.
            </summary>
            <param name="i">The zero-based field index.</param>
            <param name="fieldoffset">The index within the row from which to start the read operation.</param>
            <param name="buffer">The buffer into which to read the stream of bytes.</param>
            <param name="bufferoffset">A 32-bit integer that represents the index in the buffer at which storing begins.</param>
            <param name="length">A 32-bit integer that represents the number of characters to get.</param>
            <returns>The number of characters retrieved.</returns>
        </member>
        <member name="M:HSS.Data.DataRowReader.GetDataTypeName(System.Int32)">
            <summary>
            Gets the data type information for the specified field.
            </summary>
            <param name="i">The zero-based field index.</param>
            <returns>The data type information for the specified field.</returns>
        </member>
        <member name="M:HSS.Data.DataRowReader.GetDateTime(System.Int32)">
            <summary>
            Gets the DateTime value of the specified field.
            </summary>
            <param name="i">The zero-based field index.</param>
            <returns>The DateTime value of the specified field.</returns>
            <remarks>
            <para>
            The data retrieved must already be of the requested type or a string that can be parsed to the requested type, or an exception is generated.
            </para>
            <para>
            Call <see cref="M:HSS.Data.DataRowReader.IsDBNull(System.Int32)"/> to check for null values before calling this method or set <see cref="P:HSS.Data.DataRowReader.ValidateNull"/> to <c>false</c>.
            </para>
            <para>
            To bypass Type validation, set <see cref="P:HSS.Data.DataRowReader.ValidateType"/> to <c>false</c>. When false, will return the default DateTime value.
            </para>
            <para>
            To bypass Empty String validation (when underlying value is a string), set <see cref="P:HSS.Data.DataRowReader.ValidateEmptyString"/> to <c>false</c>. When false, will return the default DateTime value.
            </para>
            </remarks>
            <exception cref="T:System.IndexOutOfRangeException">The index passed was outside the range of 0 through <see cref="P:HSS.Data.DataRowReader.FieldCount"/>.</exception>
            <exception cref="T:System.NullReferenceException">The value 'null' was found where an instance of an object was required.</exception>
            <exception cref="T:System.InvalidCastException">The specified cast is not valid; the underlying value must be of type DateTime or String.</exception>
            <exception cref="T:System.InvalidOperationException">The value is an empty string and cannot be parsed into a valid DateTime.</exception>
        </member>
        <member name="M:HSS.Data.DataRowReader.GetDecimal(System.Int32)">
            <summary>
            Gets the fixed-position numeric value of the specified field.
            </summary>
            <param name="i">The zero-based field index.</param>
            <returns>The fixed-position numeric value of the specified field.</returns>
            <remarks>
            <para>
            The data retrieved must already be of the requested type or a string that can be parsed to the requested type, or an exception is generated.
            </para>
            <para>
            Call <see cref="M:HSS.Data.DataRowReader.IsDBNull(System.Int32)"/> to check for null values before calling this method or set <see cref="P:HSS.Data.DataRowReader.ValidateNull"/> to <c>false</c>.
            </para>
            <para>
            To bypass Type validation, set <see cref="P:HSS.Data.DataRowReader.ValidateType"/> to <c>false</c>. When false, will return the default Decimal value.
            </para>
            <para>
            To bypass Empty String validation (when underlying value is a string), set <see cref="P:HSS.Data.DataRowReader.ValidateEmptyString"/> to <c>false</c>. When false, will return the default Decimal value.
            </para>
            </remarks>
            <exception cref="T:System.IndexOutOfRangeException">The index passed was outside the range of 0 through <see cref="P:HSS.Data.DataRowReader.FieldCount"/>.</exception>
            <exception cref="T:System.NullReferenceException">The value 'null' was found where an instance of an object was required.</exception>
            <exception cref="T:System.InvalidCastException">The specified cast is not valid; the underlying value must be of type Decimal or String.</exception>
            <exception cref="T:System.InvalidOperationException">The value is an empty string and cannot be parsed into a valid Decimal.</exception>
        </member>
        <member name="M:HSS.Data.DataRowReader.GetDouble(System.Int32)">
            <summary>
            Gets the double-precision floating point number of the specified field.
            </summary>
            <param name="i">The zero-based field index.</param>
            <returns>The double-precision floating point number of the specified field.</returns>
            <remarks>
            <para>
            The data retrieved must already be of the requested type or a string that can be parsed to the requested type, or an exception is generated.
            </para>
            <para>
            Call <see cref="M:HSS.Data.DataRowReader.IsDBNull(System.Int32)"/> to check for null values before calling this method or set <see cref="P:HSS.Data.DataRowReader.ValidateNull"/> to <c>false</c>.
            </para>
            <para>
            To bypass Type validation, set <see cref="P:HSS.Data.DataRowReader.ValidateType"/> to <c>false</c>. When false, will return the default Double value.
            </para>
            <para>
            To bypass Empty String validation (when underlying value is a string), set <see cref="P:HSS.Data.DataRowReader.ValidateEmptyString"/> to <c>false</c>. When false, will return the default Double value.
            </para>
            </remarks>
            <exception cref="T:System.IndexOutOfRangeException">The index passed was outside the range of 0 through <see cref="P:HSS.Data.DataRowReader.FieldCount"/>.</exception>
            <exception cref="T:System.NullReferenceException">The value 'null' was found where an instance of an object was required.</exception>
            <exception cref="T:System.InvalidCastException">The specified cast is not valid; the underlying value must be of type Double or String.</exception>
            <exception cref="T:System.InvalidOperationException">The value is an empty string and cannot be parsed into a valid Double.</exception>
        </member>
        <member name="M:HSS.Data.DataRowReader.GetFieldType(System.Int32)">
            <summary>
            Gets the Type information corresponding to the type of Object that would be returned from GetValue.
            </summary>
            <param name="i">The zero-based field index.</param>
            <returns>The Type information corresponding to the type of Object that would be returned from GetValue.</returns>
            <exception cref="T:System.IndexOutOfRangeException">The index passed was outside the range of 0 through <see cref="P:HSS.Data.DataRowReader.FieldCount"></see>.</exception>
        </member>
        <member name="M:HSS.Data.DataRowReader.GetFloat(System.Int32)">
            <summary>
            Gets the single-precision floating point number of the specified field.
            </summary>
            <param name="i">The zero-based field index.</param>
            <returns>The single-precision floating point number of the specified field.</returns>
            <remarks>
            <para>
            The data retrieved must already be of the requested type or a string that can be parsed to the requested type, or an exception is generated.
            </para>
            <para>
            Call <see cref="M:HSS.Data.DataRowReader.IsDBNull(System.Int32)"/> to check for null values before calling this method or set <see cref="P:HSS.Data.DataRowReader.ValidateNull"/> to <c>false</c>.
            </para>
            <para>
            To bypass Type validation, set <see cref="P:HSS.Data.DataRowReader.ValidateType"/> to <c>false</c>. When false, will return the default Float value.
            </para>
            <para>
            To bypass Empty String validation (when underlying value is a string), set <see cref="P:HSS.Data.DataRowReader.ValidateEmptyString"/> to <c>false</c>. When false, will return the default Float value.
            </para>
            </remarks>
            <exception cref="T:System.IndexOutOfRangeException">The index passed was outside the range of 0 through <see cref="P:HSS.Data.DataRowReader.FieldCount"/>.</exception>
            <exception cref="T:System.NullReferenceException">The value 'null' was found where an instance of an object was required.</exception>
            <exception cref="T:System.InvalidCastException">The specified cast is not valid; the underlying value must be of type Float or String.</exception>
            <exception cref="T:System.InvalidOperationException">The value is an empty string and cannot be parsed into a valid Float.</exception>
        </member>
        <member name="M:HSS.Data.DataRowReader.GetGuid(System.Int32)">
            <summary>
            Returns the GUID value of the specified field.
            </summary>
            <param name="i">The zero-based field index.</param>
            <returns>The GUID value of the specified field.</returns>
            <remarks>
            <para>
            The data retrieved must already be of the requested type or a string that can be parsed to the requested type, or an exception is generated.
            </para>
            <para>
            Call <see cref="M:HSS.Data.DataRowReader.IsDBNull(System.Int32)"/> to check for null values before calling this method or set <see cref="P:HSS.Data.DataRowReader.ValidateNull"/> to <c>false</c>.
            </para>
            <para>
            To bypass Type validation, set <see cref="P:HSS.Data.DataRowReader.ValidateType"/> to <c>false</c>. When false, will return the default Guid value.
            </para>
            <para>
            To bypass Empty String validation (when underlying value is a string), set <see cref="P:HSS.Data.DataRowReader.ValidateEmptyString"/> to <c>false</c>. When false, will return the default Guid value.
            </para>
            </remarks>
            <exception cref="T:System.IndexOutOfRangeException">The index passed was outside the range of 0 through <see cref="P:HSS.Data.DataRowReader.FieldCount"/>.</exception>
            <exception cref="T:System.NullReferenceException">The value 'null' was found where an instance of an object was required.</exception>
            <exception cref="T:System.InvalidCastException">The specified cast is not valid; the underlying value must be of type Guid or String.</exception>
            <exception cref="T:System.InvalidOperationException">The value is an empty string and cannot be parsed into a valid Guid.</exception>
        </member>
        <member name="M:HSS.Data.DataRowReader.GetInt16(System.Int32)">
            <summary>
            Gets the 16-bit signed integer value of the specified field.
            </summary>
            <param name="i">The zero-based field index.</param>
            <returns>The 16-bit signed integer value of the specified field.</returns>
            <remarks>
            <para>
            The data retrieved must already be of the requested type or a string that can be parsed to the requested type, or an exception is generated.
            </para>
            <para>
            Call <see cref="M:HSS.Data.DataRowReader.IsDBNull(System.Int32)"/> to check for null values before calling this method or set <see cref="P:HSS.Data.DataRowReader.ValidateNull"/> to <c>false</c>.
            </para>
            <para>
            To bypass Type validation, set <see cref="P:HSS.Data.DataRowReader.ValidateType"/> to <c>false</c>. When false, will return the default Int16 value.
            </para>
            <para>
            To bypass Empty String validation (when underlying value is a string), set <see cref="P:HSS.Data.DataRowReader.ValidateEmptyString"/> to <c>false</c>. When false, will return the default Int16 value.
            </para>
            </remarks>
            <exception cref="T:System.IndexOutOfRangeException">The index passed was outside the range of 0 through <see cref="P:HSS.Data.DataRowReader.FieldCount"/>.</exception>
            <exception cref="T:System.NullReferenceException">The value 'null' was found where an instance of an object was required.</exception>
            <exception cref="T:System.InvalidCastException">The specified cast is not valid; the underlying value must be of type Int16 or String.</exception>
            <exception cref="T:System.InvalidOperationException">The value is an empty string and cannot be parsed into a valid Int16.</exception>
        </member>
        <member name="M:HSS.Data.DataRowReader.GetInt32(System.Int32)">
            <summary>
            Gets the 32-bit signed integer value of the specified field.
            </summary>
            <param name="i">The zero-based field index.</param>
            <returns>The 32-bit signed integer value of the specified field.</returns>
            <remarks>
            <para>
            The data retrieved must already be of the requested type or a string that can be parsed to the requested type, or an exception is generated.
            </para>
            <para>
            Call <see cref="M:HSS.Data.DataRowReader.IsDBNull(System.Int32)"/> to check for null values before calling this method or set <see cref="P:HSS.Data.DataRowReader.ValidateNull"/> to <c>false</c>.
            </para>
            <para>
            To bypass Type validation, set <see cref="P:HSS.Data.DataRowReader.ValidateType"/> to <c>false</c>. When false, will return the default Int32 value.
            </para>
            <para>
            To bypass Empty String validation (when underlying value is a string), set <see cref="P:HSS.Data.DataRowReader.ValidateEmptyString"/> to <c>false</c>. When false, will return the default Int32 value.
            </para>
            </remarks>
            <exception cref="T:System.IndexOutOfRangeException">The index passed was outside the range of 0 through <see cref="P:HSS.Data.DataRowReader.FieldCount"/>.</exception>
            <exception cref="T:System.NullReferenceException">The value 'null' was found where an instance of an object was required.</exception>
            <exception cref="T:System.InvalidCastException">The specified cast is not valid; the underlying value must be of type Int32 or String.</exception>
            <exception cref="T:System.InvalidOperationException">The value is an empty string and cannot be parsed into a valid Int32.</exception>
        </member>
        <member name="M:HSS.Data.DataRowReader.GetInt64(System.Int32)">
            <summary>
            Gets the 64-bit signed integer value of the specified field.
            </summary>
            <param name="i">The zero-based field index.</param>
            <returns>The 64-bit signed integer value of the specified field.</returns>
            <remarks>
            <para>
            The data retrieved must already be of the requested type or a string that can be parsed to the requested type, or an exception is generated.
            </para>
            <para>
            Call <see cref="M:HSS.Data.DataRowReader.IsDBNull(System.Int32)"/> to check for null values before calling this method or set <see cref="P:HSS.Data.DataRowReader.ValidateNull"/> to <c>false</c>.
            </para>
            <para>
            To bypass Type validation, set <see cref="P:HSS.Data.DataRowReader.ValidateType"/> to <c>false</c>. When false, will return the default Int64 value.
            </para>
            <para>
            To bypass Empty String validation (when underlying value is a string), set <see cref="P:HSS.Data.DataRowReader.ValidateEmptyString"/> to <c>false</c>. When false, will return the default Int64 value.
            </para>
            </remarks>
            <exception cref="T:System.IndexOutOfRangeException">The index passed was outside the range of 0 through <see cref="P:HSS.Data.DataRowReader.FieldCount"/>.</exception>
            <exception cref="T:System.NullReferenceException">The value 'null' was found where an instance of an object was required.</exception>
            <exception cref="T:System.InvalidCastException">The specified cast is not valid; the underlying value must be of type Int64 or String.</exception>
            <exception cref="T:System.InvalidOperationException">The value is an empty string and cannot be parsed into a valid Int64.</exception>
        </member>
        <member name="M:HSS.Data.DataRowReader.GetName(System.Int32)">
            <summary>
            Gets the name of the specified field.
            </summary>
            <param name="i">The zero-based field index.</param>
            <returns>The name of the field or an empty string if there is no value to return.</returns>
            <exception cref="T:System.IndexOutOfRangeException">The index passed was outside the range of 0 through <see cref="P:HSS.Data.DataRowReader.FieldCount"></see>.</exception>
        </member>
        <member name="M:HSS.Data.DataRowReader.GetOrdinal(System.String)">
            <summary>
            Return the index of the named field.
            </summary>
            <param name="name">The name of the field to find.</param>
            <returns>The index of the named field.</returns>
        </member>
        <member name="M:HSS.Data.DataRowReader.GetString(System.Int32)">
            <summary>
            Gets the string value of the specified field.
            </summary>
            <param name="i">The zero-based field index.</param>
            <returns>The string value of the specified field.</returns>
            <remarks>
            <para>
            The data retrieved must already be of the requested type, or an exception is generated.
            </para>
            <para>
            Call <see cref="M:HSS.Data.DataRowReader.IsDBNull(System.Int32)"/> to check for null values before calling this method or set <see cref="P:HSS.Data.DataRowReader.ValidateNull"/> to <c>false</c>.
            </para>
            <para>
            To bypass Type validation, set <see cref="P:HSS.Data.DataRowReader.ValidateType"/> to <c>false</c>. When false, will return the default String value.
            </para>
            </remarks>
            <exception cref="T:System.IndexOutOfRangeException">The index passed was outside the range of 0 through <see cref="P:HSS.Data.DataRowReader.FieldCount"/>.</exception>
            <exception cref="T:System.NullReferenceException">The value 'null' was found where an instance of an object was required.</exception>
            <exception cref="T:System.InvalidCastException">The specified cast is not valid; the underlying value must be of type String.</exception>
        </member>
        <member name="M:HSS.Data.DataRowReader.GetValue(System.Int32)">
            <summary>
            Return the value of the specified field.
            </summary>
            <param name="i">The zero-based field index.</param>
            <returns>The System.Object which will contain the field value upon return.</returns>
            <exception cref="T:System.IndexOutOfRangeException">The index passed was outside the range of 0 through <see cref="P:HSS.Data.DataRowReader.FieldCount"></see>.</exception>
        </member>
        <member name="M:HSS.Data.DataRowReader.GetValues(System.Object[])">
            <summary>
            Populates an array of objects with the field values of the current record.
            </summary>
            <param name="values">An array of System.Object to copy the attribute fields into.</param>
            <returns>The number of instances of System.Object in the array.</returns>
        </member>
        <member name="M:HSS.Data.DataRowReader.IsDBNull(System.Int32)">
            <summary>
            Return whether the specified field is set to null or DBNull.
            </summary>
            <param name="i">The zero-based field index.</param>
            <returns>true if the specified field is set to null; otherwise, false.</returns>
            <exception cref="T:System.IndexOutOfRangeException">The index passed was outside the range of 0 through <see cref="P:HSS.Data.DataRowReader.FieldCount"></see>.</exception>
        </member>
        <member name="M:HSS.Data.DataRowReader.GetData(System.Int32)">
            <summary>
            Not implemented
            </summary>
            <param name="i"></param>
            <returns></returns>
        </member>
        <member name="M:HSS.Data.DataRowReader.GetChar(System.Int32)">
            <summary>
            Not implemented
            </summary>
            <param name="i"></param>
            <returns></returns>
        </member>
        <member name="P:HSS.Data.DataRowReader.HasRows">
            <summary>
            Gets a value indicating whether the DataRowReader contains one or more rows.
            </summary>
            <value>true if the DataRowReader contains one or more rows; otherwise false.</value>
        </member>
        <member name="P:HSS.Data.DataRowReader.ValidateNull">
            <summary>
            Gets or sets the ValidateNull flag.
            </summary>
            <remarks>
            <para>The default value is <c>True</c></para>
            <para>
            When the value is true, will cause an exception
            to be thrown when attempting to get a null value.
            </para>
            </remarks>
        </member>
        <member name="P:HSS.Data.DataRowReader.ValidateType">
            <summary>
            Gets or sets the ValidateType flag.
            </summary>
            <remarks>
            <para>The default value is <c>True</c></para>
            <para>
            When the value is true, will cause an exception
            to be thrown when attempting to get a value that
            is not already the correct type or is not a string.
            </para>
            </remarks>
        </member>
        <member name="P:HSS.Data.DataRowReader.ValidateEmptyString">
            <summary>
            Gets or sets the ValidateEmptyString flag.
            </summary>
            <remarks>
            <para>The default value is <c>True</c></para>
            <para>
            When the value is true, will cause an exception
            to be thrown when attempting to get a value that
            is an empty string.
            </para>
            </remarks>
        </member>
        <member name="P:HSS.Data.DataRowReader.RecordsAffected">
            <summary>
            Returns the number of records returned from the DataReader
            </summary>
        </member>
        <member name="P:HSS.Data.DataRowReader.IsClosed">
            <summary>
            Is the DataRowReader Closed
            </summary>
        </member>
        <member name="P:HSS.Data.DataRowReader.Depth">
            <summary>
            Not implemented
            </summary>
        </member>
        <member name="P:HSS.Data.DataRowReader.FieldCount">
            <summary>
            Gets the number of fields in the current row.
            </summary>
        </member>
        <member name="P:HSS.Data.DataRowReader.Item(System.Int32)">
            <summary>
            Gets the value at the specified field index from the current row.
            </summary>
            <param name="i">The zero-based field index.</param>
            <returns>The value at the specified field index from the current row.</returns>
        </member>
        <member name="P:HSS.Data.DataRowReader.Item(System.String)">
            <summary>
            Gets the value at the specified field name from the current row.
            </summary>
            <param name="name">The name of the field to find.</param>
            <returns>The value at the specified field name from the current row.</returns>
        </member>
        <member name="T:HSS.Data.DataRowReader.Metadata">
            <summary>
            Contains the information regarding the Columns or Fields for the current DataRowReader
            </summary>
        </member>
        <member name="M:HSS.Data.DataRowReader.Metadata.#ctor">
            <summary>
            Constructor
            </summary>
        </member>
        <member name="M:HSS.Data.DataRowReader.Metadata.#ctor(System.Int32,System.String,System.Type,System.String)">
            <summary>
            Constructor
            </summary>
            <param name="fieldIndex">The Ordinal position of the Field</param>
            <param name="fieldName">The Name of the Field</param>
            <param name="fieldType">The Type of the Field</param>
            <param name="fieldTypeName">The TypeName of the Field</param>
        </member>
        <member name="P:HSS.Data.DataRowReader.Metadata.FieldIndex">
            <summary>
            Gets or sets the Ordinal position of the Field
            </summary>
        </member>
        <member name="P:HSS.Data.DataRowReader.Metadata.FieldName">
            <summary>
            Gets or sets the Name of the Field
            </summary>
        </member>
        <member name="P:HSS.Data.DataRowReader.Metadata.FieldType">
            <summary>
            Gets or sets the Type of the Field
            </summary>
        </member>
        <member name="P:HSS.Data.DataRowReader.Metadata.FielTypeName">
            <summary>
            Gets or sets the TypeName of the Field
            </summary>
        </member>
        <member name="T:HSS.Threading.TimerSchedule">
            <summary>
            A configuration that can be used to schedule a <see cref="T:HSS.Threading.Timer"/>
            </summary>
        </member>
        <member name="F:HSS.Threading.TimerSchedule.Monday">
            <summary>
            Monday = 2
            </summary>
        </member>
        <member name="F:HSS.Threading.TimerSchedule.Tuesday">
            <summary>
            Tuesday = 4
            </summary>
        </member>
        <member name="F:HSS.Threading.TimerSchedule.Wednesday">
            <summary>
            Wednesday = 8
            </summary>
        </member>
        <member name="F:HSS.Threading.TimerSchedule.Thursday">
            <summary>
            Thursday = 16
            </summary>
        </member>
        <member name="F:HSS.Threading.TimerSchedule.Friday">
            <summary>
            Friday = 32
            </summary>
        </member>
        <member name="F:HSS.Threading.TimerSchedule.Saturday">
            <summary>
            Saturday = 64
            </summary>
        </member>
        <member name="F:HSS.Threading.TimerSchedule.Sunday">
            <summary>
            Sunday = 128
            </summary>
        </member>
        <member name="M:HSS.Threading.TimerSchedule.#ctor">
            <summary>
            Default Constructor
            </summary>
        </member>
        <member name="M:HSS.Threading.TimerSchedule.#ctor(System.DateTime)">
            <summary>
            Creates a new Schedule set to occuring once a day at the given time with a frequency of Daily.
            </summary>
            <param name="timeOfDay">The time of day in which the timer should execute</param>
        </member>
        <member name="M:HSS.Threading.TimerSchedule.#ctor(System.String,System.String,HSS.Threading.ScheduleFrequency,System.Int32,System.Int32,HSS.Threading.ScheduleDailyType,System.DateTime,System.Int32,HSS.Threading.ScheduleIntervalFrequency,System.DateTime,System.DateTime,System.Collections.ObjectModel.Collection{HSS.Threading.ScheduleExclusion},System.String)">
            <summary>
            Creates a new Schedule using parameters specified
            </summary>
            <param name="id">The UniqueID for the Schedule</param>
            <param name="name">The friendly name for this Schedule</param>
            <param name="frequency">The Frequency of the timer; Daily, Weekly or Monthly</param>
            <param name="occurence">The Occurrence of the timer</param>
            <param name="occurenceOn">A flag indicating when the timers occurs</param>
            <param name="dailyType">Specify if the timer is to run once per day or at specified intervals through out the day</param>
            <param name="onceAt">The one point in time when the timer should run when the daily type is equal to OnceADay</param>
            <param name="interval">The interval in which the scheule should repeat given the interval frequency</param>
            <param name="intervalFrequency">The frequency of the interval in which the scheule should repeat; Continous or Every Second, Minute or Hour</param>
            <param name="intervalBegins">After this point in time, the repeating interval can run</param>
            <param name="intervalEnds">After this point in time, the repeating interval can no longer run</param>
            <param name="exclusions">Collection of times that are considered exclusions to the timer</param>
            <param name="description">Description of the timer</param>
        </member>
        <member name="M:HSS.Threading.TimerSchedule.#ctor(HSS.Threading.TimerSchedule)">
            <summary>
            Creates a new Schedule using ScheduleConfiguration specified
            </summary>
            <param name="scheduleConfig">An existing schedule to copy from.</param>
        </member>
        <member name="M:HSS.Threading.TimerSchedule.ToString">
            <summary>
            Returns the ScheduleID
            </summary>
            <returns>The ScheduleID</returns>
        </member>
        <member name="M:HSS.Threading.TimerSchedule.Create(HSS.Threading.TimerSchedule)">
            <summary>
            Initializes an Array of Schedules
            </summary>
            <param name="schedule">The first Schedule in the array.</param>
            <returns>The Schedule Array</returns>
        </member>
        <member name="P:HSS.Threading.TimerSchedule.Name">
            <summary>
            The friendly name for the data stored in this object.
            </summary>
        </member>
        <member name="P:HSS.Threading.TimerSchedule.Frequency">
            <summary>
            The Frequency of the timer; Daily, Weekly or Monthly
            </summary>
        </member>
        <member name="P:HSS.Threading.TimerSchedule.Occurrence">
            <summary>
            The Occurrence of the timer
            </summary>
        </member>
        <member name="P:HSS.Threading.TimerSchedule.OccurrenceFlag">
            <summary>
            A flag indicating when the timers occurs
            </summary>
        </member>
        <member name="P:HSS.Threading.TimerSchedule.DailyType">
            <summary>
            Specify if the timer is to run once per day or at specified intervals through out the day
            </summary>
        </member>
        <member name="P:HSS.Threading.TimerSchedule.OnceAt">
            <summary>
            The one point in time when the timer should run when the daily type is equal to OnceADay
            </summary>
        </member>
        <member name="P:HSS.Threading.TimerSchedule.Interval">
            <summary>
            The interval in which the scheule should repeat given the interval frequency
            </summary>
        </member>
        <member name="P:HSS.Threading.TimerSchedule.IntervalFrequency">
            <summary>
            The frequency of the interval in which the scheule should repeat; Continous or Every Second, Minute or Hour
            </summary>
        </member>
        <member name="P:HSS.Threading.TimerSchedule.IntervalBegins">
            <summary>
            After this point in time, the repeating interval can run
            </summary>
        </member>
        <member name="P:HSS.Threading.TimerSchedule.IntervalEnds">
            <summary>
            After this point in time, the repeating interval can no longer run
            </summary>
        </member>
        <member name="P:HSS.Threading.TimerSchedule.Exclusions">
            <summary>
            Collection of times that are considered exclusions to the timer
            </summary>
        </member>
        <member name="P:HSS.Threading.TimerSchedule.Description">
            <summary>
            A description of the timer.
            </summary>
        </member>
        <member name="T:HSS.Logging.LogEntryAttachment">
            <summary>
            An attachment tied to a LogEntry
            </summary>
        </member>
        <member name="P:HSS.Logging.LogEntryAttachment.DisplayName">
            <summary>
            The display name of the Attachment. Typically the full file name
            </summary>
        </member>
        <member name="P:HSS.Logging.LogEntryAttachment.LocalFileName">
            <summary>
            The name of the file
            </summary>
        </member>
        <member name="P:HSS.Logging.LogEntryAttachment.AttachmentID">
            <summary>
            The Id for the attachment used to reference to a Log Entry
            </summary>
        </member>
        <member name="P:HSS.Logging.LogEntryAttachment.Extension">
            <summary>
            The extension for this attachment including the period (.txt)
            </summary>
        </member>
        <member name="P:HSS.Logging.LogEntryAttachment.ContentType">
            <summary>
            The MIME Type of the data stored in this attachment
            </summary>
        </member>
        <member name="P:HSS.Logging.LogEntryAttachment.Content">
            <summary>
            The byte array containing the file contents
            </summary>
        </member>
        <member name="T:HSS.Security.Principal.Impersonator">
            <summary>
            Impersonation of a user. Allows code to execute under another
            users context.
            </summary>
            <remarks>
            Please note that the account that instantiates the Impersonator class
            needs to have the 'Act as part of operating system' privilege set in 
            order to impersonate another user regardless of downgrading or 
            elevating its access.
            
            NOTE: Should only be used to downgrade access, meaning from an Adminstrator or System
            Account and impersonating a domain user that has a more restrictive access policy
            </remarks>
        </member>
        <member name="M:HSS.Security.Principal.Impersonator.#ctor(System.String,System.String,System.String,HSS.Security.Principal.Impersonator.LogonType)">
            <summary>
            Initializes a new instance of the <see cref="T:HSS.Security.Principal.Impersonator"/> class
            and begins the impersonation of the requested user account given the 
            credentials supplied.
            </summary>
            <param name="userName">The name of the user to act as</param>
            <param name="domainName">The domain name of the user to act as</param>
            <param name="password">The password of the user to act as</param>
            <param name="loginType">The type of logon action to take, recommend 
            <see cref="T:HSS.Security.Principal.Impersonator.LogonType"/><c>.Interactive</c> in order to have access to most 
            activities otherwise use <see cref="T:HSS.Security.Principal.Impersonator.LogonType"/><c>.Service</c>, 
            <see cref="T:HSS.Security.Principal.Impersonator.LogonType"/><c>.Network</c> or <see cref="T:HSS.Security.Principal.Impersonator.LogonType"/><c>.Batch</c>
            </param>
            <remarks>
            Please note that the account that instantiates the Impersonator class
            needs to have the 'Act as part of operating system' privilege set in 
            order to impersonate another user regardless of downgrading or 
            elevating its access.
            
            NOTE: Should only be used to downgrade access, meaning from an Adminstrator or System
            Account and impersonating a domain user that has a more restrictive access policy
            </remarks>
        </member>
        <member name="M:HSS.Security.Principal.Impersonator.Dispose">
            <summary>
            Clean up resources
            </summary>
        </member>
        <member name="M:HSS.Security.Principal.Impersonator.ImpersonateValidUser(System.String,System.String,System.String,HSS.Security.Principal.Impersonator.LogonType)">
            <summary>
            Does the actual impersonation.
            </summary>
            <param name="userName">The name of the user to act as</param>
            <param name="domain">The domain name of the user to act as</param>
            <param name="password">The password of the user to act as</param>
            <param name="logonType">The type of logon action to take</param>
        </member>
        <member name="M:HSS.Security.Principal.Impersonator.UndoImpersonation">
            <summary>
            Reverts the impersonation.
            </summary>
        </member>
        <member name="T:HSS.Security.Principal.Impersonator.LogonType">
            <summary>
            The Type of Logon for impersonating
            </summary>
        </member>
        <member name="F:HSS.Security.Principal.Impersonator.LogonType.LOGON32_LOGON_INTERACTIVE">
            <summary>
            This logon type is intended for users who will be interactively using 
            the computer, such as a user being logged on by a terminal 
            server, remote shell, or similar process. This logon type has 
            the additional expense of caching logon information for disconnected 
            operations; therefore, it is inappropriate for some client/server 
            applications, such as a mail server.
            </summary>
        </member>
        <member name="F:HSS.Security.Principal.Impersonator.LogonType.LOGON32_LOGON_NETWORK">
            <summary>
            This logon type is intended for high performance servers to authenticate 
            plaintext passwords. The LogonUser function does not cache credentials 
            for this logon type.
            </summary>
        </member>
        <member name="F:HSS.Security.Principal.Impersonator.LogonType.LOGON32_LOGON_BATCH">
            <summary>
            This logon type is intended for batch servers, where processes may be 
            executing on behalf of a user without their direct intervention. This 
            type is also for higher performance servers that process many plaintext 
            authentication attempts at a time, such as mail or Web servers. The 
            LogonUser function does not cache credentials for this logon type.
            </summary>
        </member>
        <member name="F:HSS.Security.Principal.Impersonator.LogonType.LOGON32_LOGON_SERVICE">
            <summary>
            Indicates a service-type logon. The account provided must have the 
            service privilege enabled.
            </summary>
        </member>
        <member name="F:HSS.Security.Principal.Impersonator.LogonType.LOGON32_LOGON_UNLOCK">
            <summary>
            This logon type is for GINA DLLs that log on users who will be interactively 
            using the computer. This logon type can generate a unique audit record that 
            shows when the workstation was unlocked.
            </summary>
        </member>
        <member name="F:HSS.Security.Principal.Impersonator.LogonType.LOGON32_LOGON_NETWORK_CLEARTEXT">
            <summary>
            This logon type preserves the name and password in the authentication package, which 
            allows the server to make connections to other network servers while impersonating 
            the client. A server can accept plaintext credentials from a client, call 
            LogonUser, verify that the user can access the system across the network, and 
            still communicate with other servers. 
            
            Windows NT:  This value is not supported.
            </summary>
        </member>
        <member name="F:HSS.Security.Principal.Impersonator.LogonType.LOGON32_LOGON_NEW_CREDENTIALS">
            <summary>
            This logon type allows the caller to clone its current token and specify new 
            credentials for outbound connections. The new logon session has the same local 
            identifier but uses different credentials for other network connections. 
            
            This logon type is supported only by the LOGON32_PROVIDER_WINNT50 logon provider. 
            
            Windows NT:  This value is not supported.
            </summary>
        </member>
        <member name="T:HSS.IO.Zip.ZipDirEntry">
            <summary>
            This class models an entry in the directory contained within the zip file.
            The class is generally not used from within application code, though it is
            used by the ZipFile class.
            </summary>
        </member>
        <member name="M:HSS.IO.Zip.ZipDirEntry.#ctor">
            <summary>
            Constructor
            </summary>
        </member>
        <member name="M:HSS.IO.Zip.ZipDirEntry.Read(System.IO.Stream,System.Text.Encoding)">
            <summary>
            Reads one entry from the zip directory structure in the zip file. 
            </summary>
            <param name="s">the stream from which to read.</param>
            <param name="expectedEncoding">
            The text encoding to use if the entry is not marked UTF-8.
            </param>
            <returns>the entry read from the archive.</returns>
        </member>
        <member name="M:HSS.IO.Zip.ZipDirEntry.IsNotValidSig(System.Int32)">
            <summary>
            Returns true if the passed-in value is a valid signature for a ZipDirEntry. 
            </summary>
            <param name="signature">the candidate 4-byte signature value.</param>
            <returns>true, if the signature is valid according to the PKWare spec.</returns>
        </member>
        <member name="P:HSS.IO.Zip.ZipDirEntry.FileName">
            <summary>
            The filename of the file represented by the given entry.
            </summary>
        </member>
        <member name="P:HSS.IO.Zip.ZipDirEntry.Comment">
            <summary>
            Any comment associated to the given entry. Comments are generally optional.
            </summary>
        </member>
        <member name="P:HSS.IO.Zip.ZipDirEntry.IsDirectory">
            <summary>
            True if the referenced entry is a directory.  
            </summary>
        </member>
        <member name="T:HSS.Security.Cryptography.Certificates.TrustAllPolicy">
            <summary>
            Trusts all Certificates regardless of issue. Should be used with caution!
            </summary>
        </member>
        <member name="M:HSS.Security.Cryptography.Certificates.TrustAllPolicy.CheckValidationResult(System.Net.ServicePoint,System.Security.Cryptography.X509Certificates.X509Certificate,System.Net.WebRequest,System.Int32)">
            <summary>
            Allows trusts for all certificates. USE WITH CAUTION!
            </summary>
            <param name="srvPoint">The System.Net.ServicePoint that will use the certificate.</param>
            <param name="certificate">The certificate to validate.</param>
            <param name="request">The request that received the certificate.</param>
            <param name="certificateProblem">The problem that was encountered when using the certificate.</param>
            <returns>true if the certificate should be honored; otherwise, false.</returns>
        </member>
        <member name="T:HSS.Logging.LogRecord">
            <summary>
            The LogRecord Object Model
            </summary>
        </member>
        <member name="M:HSS.Logging.LogRecord.#ctor">
            <summary>
            Initializes a new instance of the LogRecord class.
            </summary>
        </member>
        <member name="M:HSS.Logging.LogRecord.#ctor(System.Int32,System.Int32,System.String,System.String,System.String,System.String,System.Int32,System.String,System.DateTime,System.String,System.String,System.String)">
            <summary>
            Initializes a new instance of the LogRecord class.
            </summary>
        </member>
        <member name="M:HSS.Logging.LogRecord.#ctor(System.Data.IDataRecord)">
            <summary>
            Initializes a new instance of the LogRecord class.
            </summary>
            <param name="dr">A <see cref="T:System.Data.IDataRecord"/> containing the data for this Entity</param>
        </member>
        <member name="M:HSS.Logging.LogRecord.ToString">
            <summary>
            Returns the Primary Key of the object.
            </summary>
            <returns>String</returns>
        </member>
        <member name="M:HSS.Logging.LogRecord.Load(System.Data.IDataRecord)">
            <summary>
            Load this instance from a <see cref="T:System.Data.IDataRecord"/>.
            </summary>
            <param name="dr">A <see cref="T:System.Data.IDataRecord"/> containing the data to load this Entity with.</param>
        </member>
        <member name="M:HSS.Logging.LogRecord.OnPropertyChanged(System.String)">
            <summary>
            Call this method when a Property's set accessor changes the value.
            </summary>
            <param name="propertyName">The name of the Property being effected.</param>
        </member>
        <member name="P:HSS.Logging.LogRecord.EventId">
            <summary>
            Gets or sets the EventId value.
            </summary>
        </member>
        <member name="P:HSS.Logging.LogRecord.EventTypeID">
            <summary>
            Gets or sets the EventTypeID value.
            </summary>
        </member>
        <member name="P:HSS.Logging.LogRecord.EventType">
            <summary>
            Gets or sets the EventType value.
            </summary>
        </member>
        <member name="P:HSS.Logging.LogRecord.Message">
            <summary>
            Gets or sets the Message value.
            </summary>
        </member>
        <member name="P:HSS.Logging.LogRecord.ApplicationName">
            <summary>
            Gets or sets the name of the application this record is associated with.
            </summary>
        </member>
        <member name="P:HSS.Logging.LogRecord.ReferenceNumber">
            <summary>
            Gets or sets the ReferenceNumber value.
            </summary>
        </member>
        <member name="P:HSS.Logging.LogRecord.CategoryID">
            <summary>
            Gets or sets the CategoryID value.
            </summary>
        </member>
        <member name="P:HSS.Logging.LogRecord.Category">
            <summary>
            Gets or sets the Category value.
            </summary>
        </member>
        <member name="P:HSS.Logging.LogRecord.CreatedDate">
            <summary>
            Gets or sets the CreatedDate value.
            </summary>
        </member>
        <member name="P:HSS.Logging.LogRecord.UserName">
            <summary>
            Gets or sets the UserName value.
            </summary>
        </member>
        <member name="P:HSS.Logging.LogRecord.HasAttachment">
            <summary>
            Gets or sets the HasAttachment value.
            </summary>
        </member>
        <member name="P:HSS.Logging.LogRecord.ViewAttachment">
            <summary>
            Gets or sets the ViewAttachment value.
            </summary>
        </member>
        <member name="P:HSS.Logging.LogRecord.ViewAttachmentLabel">
            <summary>
            Gets or sets the ViewAttachmentLabel value.
            </summary>
        </member>
        <member name="P:HSS.Logging.LogRecord.EventTypeImage">
            <summary>
            Gets the Image Source Path for the EventType.
            </summary>
        </member>
        <member name="E:HSS.Logging.LogRecord.PropertyChanged">
            <summary>
            Occurs when a property has changed.
            </summary>
        </member>
        <member name="P:HSS.Logging.LogRecord.Id">
            <summary>
            Gets the Id of this record.
            </summary>
        </member>
        <member name="P:HSS.Logging.LogRecord.Name">
            <summary>
            Gets the Name of this record (Id);
            </summary>
        </member>
        <member name="P:HSS.Logging.LogRecord.Data">
            <summary>
            Gets this instance as an Object.
            </summary>
        </member>
        <member name="T:HSS.Threading.TimerState">
            <summary>
            The state of a timer instance
            </summary>
        </member>
        <member name="F:HSS.Threading.TimerState.Started">
            <summary>
            The timer is started
            </summary>
        </member>
        <member name="F:HSS.Threading.TimerState.Stopped">
            <summary>
            The timer is stopping
            </summary>
        </member>
        <member name="F:HSS.Threading.TimerState.Stopping">
            <summary>
            The timer is stopped
            </summary>
        </member>
        <member name="F:HSS.Threading.TimerState.Paused">
            <summary>
            The timer is paused
            </summary>
        </member>
        <member name="F:HSS.Threading.TimerState.Pausing">
            <summary>
            The timer is pausing
            </summary>
        </member>
        <member name="F:HSS.Threading.TimerState.Starting">
            <summary>
            The timer is starting
            </summary>
        </member>
        <member name="T:HSS.IO.MimeMapping">
            <summary>
            Supports retrieving, and registering in memory custom MIME types, for a given file type.
            </summary>
        </member>
        <member name="M:HSS.IO.MimeMapping.AddMimeMapping(System.String,System.String)">
            <summary>
            Add a File Extension and MIME Type to the MIME Mapping. Note, the Map is already pre-filled with all the standard MIME Types and File Extensions
            </summary>
            <param name="extension">The extension of the file for the given MIME Type, including the dot (example: .ext).</param>
            <param name="mimeType">The MIME Type that maps to the provided file extension</param>
            <returns>true if the extension was added; otherwise false.</returns>
        </member>
        <member name="M:HSS.IO.MimeMapping.FromFileName(System.String)">
            <summary>
            Retrieve the MIME type for a given file name
            </summary>
            <param name="fileName">The name of the file including extension (example: file.ext)</param>
            <returns>The MIME Type found; otherwise 'application/octet-stream'.</returns>
        </member>
        <member name="M:HSS.IO.MimeMapping.FromFileExtension(System.String)">
            <summary>
            Retrieve the MIME type for a given file extension
            </summary>
            <param name="fileExtension">The extension of file (example: .ext)</param>
            <returns>The MIME Type found; otherwise 'application/octet-stream'.</returns>
        </member>
        <member name="T:HSS.Logging.ILogServer">
            <summary>
            The Interface for a LogServer
            </summary>
        </member>
        <member name="M:HSS.Logging.ILogServer.Ping">
            <summary>
            A method a client object can call to validate the server object exist
            </summary>
            <returns>true</returns>
        </member>
        <member name="M:HSS.Logging.ILogServer.GetLogType">
            <summary>
            Gets the current EventLogType.
            </summary>
            <returns>The <see cref="T:HSS.Logging.EventLogType"/>.</returns>
        </member>
        <member name="M:HSS.Logging.ILogServer.SetConfig(System.String,System.String,System.Int32,System.Boolean,System.DateTime,System.Int32,System.String)">
            <summary>
            Set the Log Configuration for the instance
            </summary>
            <param name="id">The unique Id for this Configuration</param>
            <param name="name">The friendly name for this Configuration</param>
            <param name="logType">The Type of log to write event entries to</param>
            <param name="autoTruncate">Indicate whether or not to auto truncate the eventlog</param>
            <param name="truncateAt">If AutoTruncate is true indicates the time of day in which to execute the Truncate Command</param>
            <param name="daysToRetain">If AutoTruncate is true indicates the number of days to retain</param>
            <param name="dbConnString">The Id of the Database Configuration to use</param>
        </member>
        <member name="M:HSS.Logging.ILogServer.GetConfig">
            <summary>
            Returns an EventLog Configuration
            </summary>
            <returns>An EventLog Configuration</returns>
        </member>
        <member name="M:HSS.Logging.ILogServer.ValidateDbConnection(System.Boolean)">
            <summary>
            Validate the database connection for event logging
            </summary>
            <param name="verbose">Indicate if the results are to be displayed</param>
            <returns>The <see cref="T:HSS.Logging.ValidationResults"/> instance contain the results</returns>
        </member>
        <member name="M:HSS.Logging.ILogServer.GetEntries(System.Int32@,System.Int32,System.Int32,System.Int32,System.String,System.String,System.String,System.String,System.DateTime,System.DateTime)">
            <summary>
            Gets a filtered list of entries from the HSS Database EventLog table.
            </summary>
            <param name="pages">Reference to the number of pages.</param>
            <param name="page">The desired page.</param>
            <param name="recPerPage">The number of records per page.</param>
            <param name="eventTypeMask">The Mask of EventTypes to filter for.</param>
            <param name="applicationName">The Application to filter for.</param>
            <param name="referenceNumber">The Reference Number to filter for.</param>
            <param name="category">The category to filter for.</param>
            <param name="userName">The UserName associated with the entry.</param>
            <param name="beginDate">The Created Date of the entry must be greater than or equal to this date.</param>
            <param name="endDate">The Created Date of the entry must be less than or equal to this date.</param>
            <returns>A list of LogRecords containing the EventLog data.</returns>
        </member>
        <member name="M:HSS.Logging.ILogServer.GetCategories">
            <summary>
            Retrieve the list of Categories from the Database.
            </summary>
            <returns>A List of <see cref="T:HSS.Logging.LogCategory"/> objects.</returns>
        </member>
        <member name="M:HSS.Logging.ILogServer.GetEventTypes">
            <summary>
            Retrieve the list of Event Types from the Database.
            </summary>
            <returns>A List of <see cref="T:HSS.Logging.LogEventType"/> objects.</returns>
        </member>
        <member name="M:HSS.Logging.ILogServer.GetAttachment(System.Int32)">
            <summary>
            Retrieve an Attachment from the Database
            </summary>
            <param name="attachmentId">The id of the attachment to retrieve</param>
            <returns>A <see cref="T:HSS.Logging.LogEntryAttachment"/></returns>
        </member>
        <member name="T:HSS.Logging.Strings">
            <summary>
              A strongly-typed resource class, for looking up localized strings, etc.
            </summary>
        </member>
        <member name="P:HSS.Logging.Strings.ResourceManager">
            <summary>
              Returns the cached ResourceManager instance used by this class.
            </summary>
        </member>
        <member name="P:HSS.Logging.Strings.Culture">
            <summary>
              Overrides the current thread's CurrentUICulture property for all
              resource lookups using this strongly typed resource class.
            </summary>
        </member>
        <member name="P:HSS.Logging.Strings.ExceptionLogging_AttachmentDatabaseOnly">
            <summary>
              Looks up a localized string similar to You can only add attachments when the LogType is set to Database..
            </summary>
        </member>
        <member name="P:HSS.Logging.Strings.ExceptionLoggingMessage">
             <summary>
               Looks up a localized string similar to Error enountered logging the following message:
            {0}
            
            Exception:
            {1}.
             </summary>
        </member>
        <member name="T:HSS.Logging.LogEventType">
            <summary>
            LogEventType represents an EventType from the HSS Log System.
            </summary>
        </member>
        <member name="M:HSS.Logging.LogEventType.#ctor">
            <summary>
            Constructor
            </summary>
        </member>
        <member name="M:HSS.Logging.LogEventType.#ctor(System.Data.IDataRecord)">
            <summary>
            Constructor
            </summary>
            <param name="dr">The <see cref="T:System.Data.IDataRecord"/> to construct this instance from.</param>
        </member>
        <member name="M:HSS.Logging.LogEventType.Load(System.Data.IDataRecord)">
            <summary>
            Loads this instance from the provided <see cref="T:System.Data.IDataRecord"/>.
            </summary>
            <param name="dr"></param>
        </member>
        <member name="P:HSS.Logging.LogEventType.Id">
            <summary>
            The UniqueId for this record.
            </summary>
        </member>
        <member name="P:HSS.Logging.LogEventType.Name">
            <summary>
            The Name for this record.
            </summary>
        </member>
        <member name="P:HSS.Logging.LogEventType.Data">
            <summary>
            Gets this instance as an object.
            </summary>
        </member>
        <member name="P:HSS.Logging.LogEventType.EventTypeId">
            <summary>
            Gets or sets the EventType Id.
            </summary>
        </member>
        <member name="P:HSS.Logging.LogEventType.EventType">
            <summary>
            Gets or sets the EventType Name.
            </summary>
        </member>
        <member name="P:HSS.Logging.LogEventType.Description">
            <summary>
            Gets or sets the EventType Description.
            </summary>
        </member>
        <member name="T:HSS.Logging.ILogServerChannel">
            <summary>
            ILogServerChannel is used to communicate with the HSS Logging Server. <see cref="T:HSS.Logging.Log"/>.
            </summary>
        </member>
        <member name="T:HSS.IO.Zip.BadPasswordException">
            <summary>
            Issued when an <c>ZipEntry.ExtractWithPassword()</c> method is invoked
            with an incorrect password.
            </summary>
        </member>
        <member name="T:HSS.IO.Zip.ZipException">
            <summary>
            Base class for all exceptions defined by and throw by the Zip library.
            </summary>
        </member>
        <member name="M:HSS.IO.Zip.ZipException.#ctor">
            <summary>
            Default ctor.
            </summary>
        </member>
        <member name="M:HSS.IO.Zip.ZipException.#ctor(System.String)">
            <summary>
            Come on, you know how exceptions work. Why are you looking at this documentation?
            </summary>
            <param name="message">The message in the exception.</param>
        </member>
        <member name="M:HSS.IO.Zip.ZipException.#ctor(System.String,System.Exception)">
            <summary>
            Come on, you know how exceptions work. Why are you looking at this documentation?
            </summary>
            <param name="message">The message in the exception.</param>
            <param name="innerException">The innerException for this exception.</param>
        </member>
        <member name="M:HSS.IO.Zip.ZipException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
            <summary>
            Come on, you know how exceptions work. Why are you looking at this documentation?
            </summary>
            <param name="serializationInfo">The serialization info for the exception.</param>
            <param name="streamingContext">The streaming context from which to deserialize.</param>
        </member>
        <member name="M:HSS.IO.Zip.BadPasswordException.#ctor">
            <summary>
            Default ctor.
            </summary>
        </member>
        <member name="M:HSS.IO.Zip.BadPasswordException.#ctor(System.String)">
            <summary>
            Come on, you know how exceptions work. Why are you looking at this documentation?
            </summary>
            <param name="message">The message in the exception.</param>
        </member>
        <member name="M:HSS.IO.Zip.BadPasswordException.#ctor(System.String,System.Exception)">
            <summary>
            Come on, you know how exceptions work. Why are you looking at this documentation?
            </summary>
            <param name="message">The message in the exception.</param>
            <param name="innerException">The innerException for this exception.</param>
        </member>
        <member name="M:HSS.IO.Zip.BadPasswordException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
            <summary>
            Come on, you know how exceptions work. Why are you looking at this documentation?
            </summary>
            <param name="serializationInfo">The serialization info for the exception.</param>
            <param name="streamingContext">The streaming context from which to deserialize.</param>
        </member>
        <member name="T:HSS.IO.Zip.BadReadException">
            <summary>
            Indicates that a read was attempted on a stream, and bad or incomplete data was
            received.  
            </summary>
        </member>
        <member name="M:HSS.IO.Zip.BadReadException.#ctor">
            <summary>
            Default ctor.
            </summary>
        </member>
        <member name="M:HSS.IO.Zip.BadReadException.#ctor(System.String)">
            <summary>
            Come on, you know how exceptions work. Why are you looking at this documentation?
            </summary>
            <param name="message">The message in the exception.</param>
        </member>
        <member name="M:HSS.IO.Zip.BadReadException.#ctor(System.String,System.Exception)">
            <summary>
            Come on, you know how exceptions work. Why are you looking at this documentation?
            </summary>
            <param name="message">The message in the exception.</param>
            <param name="innerException">The innerException for this exception.</param>
        </member>
        <member name="M:HSS.IO.Zip.BadReadException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
            <summary>
            Come on, you know how exceptions work. Why are you looking at this documentation?
            </summary>
            <param name="serializationInfo">The serialization info for the exception.</param>
            <param name="streamingContext">The streaming context from which to deserialize.</param>
        </member>
        <member name="T:HSS.IO.Zip.BadCRCException">
            <summary>
            Issued when an CRC check fails upon extracting an entry from a zip archive.
            </summary>
        </member>
        <member name="M:HSS.IO.Zip.BadCRCException.#ctor">
            <summary>
            Default ctor.
            </summary>
        </member>
        <member name="M:HSS.IO.Zip.BadCRCException.#ctor(System.String)">
            <summary>
            Come on, you know how exceptions work. Why are you looking at this documentation?
            </summary>
            <param name="message">The message in the exception.</param>
        </member>
        <member name="M:HSS.IO.Zip.BadCRCException.#ctor(System.String,System.Exception)">
            <summary>
            Come on, you know how exceptions work. Why are you looking at this documentation?
            </summary>
            <param name="message">The message in the exception.</param>
            <param name="innerException">The innerException for this exception.</param>
        </member>
        <member name="M:HSS.IO.Zip.BadCRCException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
            <summary>
            Come on, you know how exceptions work. Why are you looking at this documentation?
            </summary>
            <param name="serializationInfo">The serialization info for the exception.</param>
            <param name="streamingContext">The streaming context from which to deserialize.</param>
        </member>
        <member name="T:HSS.IO.Zip.SfxGenerationException">
            <summary>
            Issued when errors occur saving a self-extracting archive.
            </summary>
        </member>
        <member name="M:HSS.IO.Zip.SfxGenerationException.#ctor">
            <summary>
            Default ctor.
            </summary>
        </member>
        <member name="M:HSS.IO.Zip.SfxGenerationException.#ctor(System.String)">
            <summary>
            Come on, you know how exceptions work. Why are you looking at this documentation?
            </summary>
            <param name="message">The message in the exception.</param>
        </member>
        <member name="M:HSS.IO.Zip.SfxGenerationException.#ctor(System.String,System.Exception)">
            <summary>
            Come on, you know how exceptions work. Why are you looking at this documentation?
            </summary>
            <param name="message">The message in the exception.</param>
            <param name="innerException">The innerException for this exception.</param>
        </member>
        <member name="M:HSS.IO.Zip.SfxGenerationException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
            <summary>
            Come on, you know how exceptions work. Why are you looking at this documentation?
            </summary>
            <param name="serializationInfo">The serialization info for the exception.</param>
            <param name="streamingContext">The streaming context from which to deserialize.</param>
        </member>
        <member name="T:HSS.IO.Zip.BadStateException">
            <summary>
            Indicates that an operation was attempted on a ZipFile which was not possible
            given the state of the instance. For example, if you call <c>Save()</c> on a ZipFile 
            which has no filename set, you can get this exception. 
            </summary>
        </member>
        <member name="M:HSS.IO.Zip.BadStateException.#ctor">
            <summary>
            Default ctor.
            </summary>
        </member>
        <member name="M:HSS.IO.Zip.BadStateException.#ctor(System.String)">
            <summary>
            Come on, you know how exceptions work. Why are you looking at this documentation?
            </summary>
            <param name="message">The message in the exception.</param>
        </member>
        <member name="M:HSS.IO.Zip.BadStateException.#ctor(System.String,System.Exception)">
            <summary>
            Come on, you know how exceptions work. Why are you looking at this documentation?
            </summary>
            <param name="message">The message in the exception.</param>
            <param name="innerException">The innerException for this exception.</param>
        </member>
        <member name="M:HSS.IO.Zip.BadStateException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
            <summary>
            Come on, you know how exceptions work. Why are you looking at this documentation?
            </summary>
            <param name="serializationInfo">The serialization info for the exception.</param>
            <param name="streamingContext">The streaming context from which to deserialize.</param>
        </member>
        <member name="T:HSS.Threading.ScheduleFrequency">
            <summary>
            A Schedules frequency
            </summary>
        </member>
        <member name="F:HSS.Threading.ScheduleFrequency.Daily">
            <summary>
            Specify interval in days
            </summary>
        </member>
        <member name="F:HSS.Threading.ScheduleFrequency.Weekly">
            <summary>
            Specify interval in weeks
            </summary>
        </member>
        <member name="F:HSS.Threading.ScheduleFrequency.Monthly">
            <summary>
            Specify interval in months
            </summary>
        </member>
        <member name="T:HSS.Threading.ScheduleDailyType">
            <summary>
            A Schedules daily type. Either once a day or repeatedly specifing an interval and interval frequency
            </summary>
        </member>
        <member name="F:HSS.Threading.ScheduleDailyType.OnceADay">
            <summary>
            Indicates a timer should only run once a day
            </summary>
        </member>
        <member name="F:HSS.Threading.ScheduleDailyType.Repeatedly">
            <summary>
            Indicates a timer should run repeatedly using an interval and interval frequency
            </summary>
        </member>
        <member name="T:HSS.Threading.ScheduleIntervalFrequency">
            <summary>
            A Schedules interval frequency
            </summary>
        </member>
        <member name="F:HSS.Threading.ScheduleIntervalFrequency.Seconds">
            <summary>
            Specify interval in Seconds
            </summary>
        </member>
        <member name="F:HSS.Threading.ScheduleIntervalFrequency.Minutes">
            <summary>
            Specify interval in Minutes
            </summary>
        </member>
        <member name="F:HSS.Threading.ScheduleIntervalFrequency.Hours">
            <summary>
            Specify interval in Hours
            </summary>
        </member>
        <member name="F:HSS.Threading.ScheduleIntervalFrequency.Continuous">
            <summary>
            Run Continuously
            </summary>
        </member>
        <member name="T:HSS.AsyncResult`1">
            <summary>
            A generic implementation of <see cref="T:System.IAsyncResult"/> with a Type specified result
            </summary>
            <remarks>Courtesy of Jeffrey Richter (http://msdn.microsoft.com/msdnmag/issues/07/03/ConcurrentAffairs/)</remarks>
            <typeparam name="TResult">The type of the result object</typeparam>
        </member>
        <member name="M:HSS.AsyncResult`1.#ctor(System.AsyncCallback,System.Object)">
            <summary>
            Constructor
            </summary>
            <param name="asyncCallback">AsyncCallback</param>
            <param name="state">Object state</param>
        </member>
        <member name="M:HSS.AsyncResult`1.SetAsCompleted(`0,System.Boolean)">
            <summary>
            Indicate completion
            </summary>
            <param name="result">The results of the operation</param>
            <param name="completedSynchronously">Did it complete synchronously</param>
        </member>
        <member name="M:HSS.AsyncResult`1.EndInvoke">
            <summary>
            Wait for operation to complete
            </summary>
            <returns>The TResult</returns>
        </member>
    </members>
</doc>
